# Bluesky Scraper — Posts, Profiles & Followers (`nomad-agent/bluesky-scraper`) Actor

All-in-one Bluesky data extractor built on the official AT Protocol public API. Search posts by keyword or hashtag with date filters, pull any user's full post feed, fetch profile details, or list followers and following. Clean JSON with engagement counts — no login, no proxies, no HTML parsing.

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

## Pricing

Pay per event

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

## Bluesky Scraper — Posts, Profiles & Followers

Extract Bluesky data in one Actor: search posts by keyword or hashtag, pull any account's post feed, fetch profile details, or list followers and following — all through the official AT Protocol public API. No login, no cookies, no proxies.

### What Bluesky data does this scraper extract?

**Post records** (`search` and `authorFeed` modes) — one flat JSON record per post:

| Field | Meaning |
|---|---|
| `uri` / `cid` | Stable AT Protocol identifiers of the post |
| `url` | Direct bsky.app link to the post |
| `authorHandle` / `authorDid` / `authorDisplayName` | Who posted it |
| `text` | Full post text |
| `createdAt` / `indexedAt` | When it was posted / indexed |
| `likeCount` / `repostCount` / `replyCount` / `quoteCount` | Engagement counts |
| `langs` | Declared post languages |
| `isRepost` / `feedOf` | Repost flag and source handle (`authorFeed` mode) |
| `mode` | Which mode produced the record |

**Profile records** (`profile`, `followers`, `following` modes): `did`, `handle`, `url`, `displayName`, `description`, `avatar`, `createdAt`, plus `followersCount` / `followsCount` / `postsCount` in `profile` mode and `subjectHandle` in follower/following modes.

### Modes

| Mode | What it returns | Key inputs |
|---|---|---|
| `search` | Posts matching a keyword/hashtag, with date, author, mention, language and engagement filters | `query`, `since`, `until`, `fromAuthor`, `mentionsAuthor`, `language`, `sort`, `minLikes`, `minReposts` |
| `authorFeed` | Posts by one or more accounts | `handles`, `includeReplies`, `minLikes`, `minReposts` |
| `profile` | Profile details (bio, counts) per account | `handles` |
| `followers` | Accounts following the given handles | `handles` |
| `following` | Accounts the given handles follow | `handles` |

Search supports Bluesky query operators typed straight into `query` — `#hashtag`, `"exact phrase"`, `from:user.bsky.social`, `mentions:user.bsky.social`, `lang:en`, and more. The most common ones also have dedicated inputs so you don't have to remember the operator syntax:

- **`fromAuthor`** — only posts written by this handle (same as `from:`). Uses `searchPosts`' own `author` filter param, not just a query-string trick.
- **`mentionsAuthor`** — only posts that mention this handle (same as `mentions:`). Uses the `mentions` filter param.
- **`language`** — only posts declared in this ISO 639-1 language code (same as `lang:`). Uses the `lang` filter param.

These compose safely with `query`, `since`, `until` and `sort` in the same request. The `searchPosts` endpoint also has dedicated `domain`/`url`/`tag` filter params — not yet exposed as Actor inputs, planned for a future update.

Bluesky's unauthenticated search API does not allow cursor paging, so the Actor transparently paginates `latest` searches by walking the time window backwards — you still just set `maxItems`. `top` sort is not time-ordered and returns up to 100 posts per run.

`minLikes` / `minReposts` filter posts client-side, after they're fetched from the API — set either to skip low-engagement noise in `search` and `authorFeed` results. Filtered-out posts are never pushed to the dataset, so you aren't billed for them.

### How to scrape Bluesky with this Actor

1. Click **Try for free** / **Run** — no Bluesky account needed, only public data is read.
2. Pick a `mode`, set a `query` or `handles`, adjust `maxItems` or keep the defaults.
3. Run it and export the dataset as JSON, CSV or Excel, or read it over the [API](https://docs.apify.com/api/v2).

Run it from your own code:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("nomad-jobs/bluesky-scraper").call(run_input={
    "mode": "search",
    "query": "#ai",
    "since": "2026-06-01T00:00:00Z",
    "maxItems": 200,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["authorHandle"], "—", item["text"][:80], item["url"])
````

Or a single HTTP call that runs the Actor and returns items in one response:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/nomad-jobs~bluesky-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "authorFeed", "handles": ["bsky.app"], "maxItems": 50}'
```

### Input

General fields (apply across modes):

| Field | Type | Default | Notes |
|---|---|---|---|
| `mode` | string | `search` | One of `search`, `authorFeed`, `profile`, `followers`, `following`. |
| `handles` | array | — | Handles or DIDs for `authorFeed`/`profile`/`followers`/`following`. Leading `@` optional. |
| `includeReplies` | boolean | `false` | Include the author's replies in `authorFeed` mode. |
| `maxItems` | integer | `100` | Maximum records for the whole run. Set 0 for no limit. |

Search fields (`search` mode; `minLikes`/`minReposts` also apply to `authorFeed`):

| Field | Type | Default | Notes |
|---|---|---|---|
| `query` | string | — | Keyword/hashtag for `search` mode. Supports Bluesky search operators. |
| `since` | string | — | Only posts created at or after this date/time. Datepicker (`YYYY-MM-DD`) or a precise ISO 8601 timestamp. |
| `until` | string | — | Only posts created before this date/time. Datepicker (`YYYY-MM-DD`) or a precise ISO 8601 timestamp. |
| `fromAuthor` | string | — | Only posts written by this handle (`from:` operator / `author` param). |
| `mentionsAuthor` | string | — | Only posts that mention this handle (`mentions:` operator / `mentions` param). |
| `language` | string | — | Only posts in this ISO 639-1 language code (`lang:` operator / `lang` param). |
| `sort` | string | `latest` | `latest` (newest first) or `top` (by relevance) for `search` mode. |
| `minLikes` | integer | `0` | Drop posts with fewer likes than this (compares `likeCount`). 0 = no filter. |
| `minReposts` | integer | `0` | Drop posts with fewer reposts than this (compares `repostCount`). 0 = no filter. |

### Output example

```json
{
  "mode": "search",
  "uri": "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3lb2abcxyz",
  "cid": "bafyreib2rxk3rw6...",
  "url": "https://bsky.app/profile/bsky.app/post/3lb2abcxyz",
  "authorHandle": "bsky.app",
  "authorDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "authorDisplayName": "Bluesky",
  "text": "Introducing new moderation tools...",
  "createdAt": "2026-06-15T18:02:11.000Z",
  "indexedAt": "2026-06-15T18:02:12.345Z",
  "langs": ["en"],
  "replyCount": 412,
  "repostCount": 1287,
  "likeCount": 9034,
  "quoteCount": 187
}
```

### Pricing

Pay per event: **$0.05 per Actor start** and **$0.004 per record returned**.
100 records ≈ $0.45. No subscription, no rental — you pay only for what you fetch.
`minLikes`/`minReposts` are applied before records are pushed, so filtered-out posts are never billed.

### Integrations

Export the dataset as JSON, CSV, Excel or HTML, pull it over the [Apify API](https://docs.apify.com/api/v2) (including `run-sync-get-dataset-items` for a single blocking call), wire it into Make, Zapier or n8n, or call it as a tool from an AI agent via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

### Use cases

- Brand, keyword and hashtag monitoring on Bluesky
- Social listening and sentiment datasets for AI/LLM pipelines
- Influencer discovery via follower/following graphs and engagement counts
- Archiving an account's full posting history
- Trend and virality analysis with like/repost/reply counts

### FAQ

**Is it legal to scrape Bluesky?**
This Actor reads only publicly available data through Bluesky's own public AT Protocol API (`public.api.bsky.app`) — the same data any logged-out visitor can see. No authentication is used and no private data is touched. Review Bluesky's terms and your local regulations for your specific use case.

**Do I need a Bluesky account?**
No. All five modes use unauthenticated public endpoints.

**How fresh is the data?**
Every run hits the live API. `search` with `sort: latest` returns posts within seconds of being indexed.

**How many records can I get?**
`maxItems` caps the run; set 0 to paginate until the source is exhausted (full author feeds and follower lists). The Actor follows API cursors and respects Bluesky's rate limits automatically.

**What about deleted or blocked accounts?**
Handles that cannot be resolved (typos, deactivated accounts) are logged and skipped — one bad handle never fails the whole run.

**Which search operators are supported as dedicated inputs?**
`fromAuthor`, `mentionsAuthor` and `language` map to `searchPosts`' own `author`, `mentions` and `lang` filter params (verified against the live API) — equivalent to `from:`, `mentions:` and `lang:` in `query`, but composable with it via a proper param instead of string-building. The underlying API also has `domain`/`url`/`tag` filter params; they're not wired up as Actor inputs yet.

**Something broken or missing?**
Open an issue on the Actor's **Issues** tab — it is monitored and reliability fixes ship fast.

### Related Actors

- [Hacker News Who Is Hiring Scraper — HN Jobs](https://apify.com/nomad-jobs/hackernews-scraper)
- [Web Search Scraper](https://apify.com/nomad-jobs/web-search-scraper)
- [AI & ML Engineer Jobs Scraper — 8 Boards in One](https://apify.com/nomad-jobs/ml-ai-dev-bundle)

### Credits

Independent implementation on the official AT Protocol public API. Design informed by the MIT-licensed [deepfates/bsky-scraper](https://github.com/deepfates/bsky-scraper) firehose archiver — see `LICENSE` for the attribution note.

# Actor input Schema

## `mode` (type: `string`):

What to scrape: <b>search</b> — posts matching a keyword/hashtag query; <b>authorFeed</b> — posts from specific accounts; <b>profile</b> — profile details for specific accounts; <b>followers</b> — accounts following the given handles; <b>following</b> — accounts the given handles follow.

## `handles` (type: `array`):

Bluesky handles or DIDs to scrape (used in <b>authorFeed</b>, <b>profile</b>, <b>followers</b> and <b>following</b> modes), e.g. <code>bsky.app</code> or <code>jay.bsky.team</code>. The leading <code>@</code> is optional.

## `includeReplies` (type: `boolean`):

In <b>authorFeed</b> mode, also include the author's replies (default: original posts, quotes and reposts only).

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

Maximum number of records to return across the whole run. Set 0 for no limit (paginate until the source is exhausted). Each record returned is billed — see Pricing in the README.

## `query` (type: `string`):

Keyword or hashtag to search posts for (used in <b>search</b> mode). Supports Bluesky search operators typed directly into the query, e.g. <code>#ai</code>, <code>"exact phrase"</code> — or use the dedicated <b>From author</b>, <b>Mentions author</b> and <b>Language</b> fields below instead of typing <code>from:</code>/<code>mentions:</code>/<code>lang:</code>.

## `since` (type: `string`):

Only return posts created at or after this date (used in <b>search</b> mode). Pick a date, or type a precise ISO 8601 timestamp such as <code>2026-06-01T00:00:00Z</code> for finer control.

## `until` (type: `string`):

Only return posts created before this date (used in <b>search</b> mode). Pick a date, or type a precise ISO 8601 timestamp such as <code>2026-07-01T00:00:00Z</code> for finer control.

## `fromAuthor` (type: `string`):

Only return posts written by this account (used in <b>search</b> mode). Enter a handle, e.g. <code>bsky.app</code> — same as typing <code>from:</code> into a Bluesky search. The leading <code>@</code> is optional.

## `mentionsAuthor` (type: `string`):

Only return posts that mention this account (used in <b>search</b> mode). Enter a handle, e.g. <code>bsky.app</code> — same as typing <code>mentions:</code> into a Bluesky search. The leading <code>@</code> is optional.

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

Only return posts declared in this language (used in <b>search</b> mode). Two-letter ISO 639-1 code, e.g. <code>en</code>, <code>fr</code>, <code>ja</code>.

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

Ranking for <b>search</b> mode: newest first or by relevance/engagement.

## `minLikes` (type: `integer`):

Drop posts with fewer likes than this before they are returned (applies to <b>search</b> and <b>authorFeed</b> modes; compares against each post's <code>likeCount</code>). 0 = no filter.

## `minReposts` (type: `integer`):

Drop posts with fewer reposts than this before they are returned (applies to <b>search</b> and <b>authorFeed</b> modes; compares against each post's <code>repostCount</code>). 0 = no filter.

## Actor input object example

```json
{
  "mode": "search",
  "handles": [
    "bsky.app"
  ],
  "includeReplies": false,
  "maxItems": 100,
  "query": "#ai",
  "sort": "latest",
  "minLikes": 0,
  "minReposts": 0
}
```

# 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 = {
    "handles": [
        "bsky.app"
    ],
    "query": "#ai"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nomad-agent/bluesky-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 = {
    "handles": ["bsky.app"],
    "query": "#ai",
}

# Run the Actor and wait for it to finish
run = client.actor("nomad-agent/bluesky-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 '{
  "handles": [
    "bsky.app"
  ],
  "query": "#ai"
}' |
apify call nomad-agent/bluesky-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Scraper — Posts, Profiles & Followers",
        "description": "All-in-one Bluesky data extractor built on the official AT Protocol public API. Search posts by keyword or hashtag with date filters, pull any user's full post feed, fetch profile details, or list followers and following. Clean JSON with engagement counts — no login, no proxies, no HTML parsing.",
        "version": "0.1",
        "x-build-id": "dBIMGMhBcgdOxnZD6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nomad-agent~bluesky-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nomad-agent-bluesky-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/nomad-agent~bluesky-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nomad-agent-bluesky-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/nomad-agent~bluesky-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nomad-agent-bluesky-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "authorFeed",
                            "profile",
                            "followers",
                            "following"
                        ],
                        "type": "string",
                        "description": "What to scrape: <b>search</b> — posts matching a keyword/hashtag query; <b>authorFeed</b> — posts from specific accounts; <b>profile</b> — profile details for specific accounts; <b>followers</b> — accounts following the given handles; <b>following</b> — accounts the given handles follow.",
                        "default": "search"
                    },
                    "handles": {
                        "title": "Handles",
                        "type": "array",
                        "description": "Bluesky handles or DIDs to scrape (used in <b>authorFeed</b>, <b>profile</b>, <b>followers</b> and <b>following</b> modes), e.g. <code>bsky.app</code> or <code>jay.bsky.team</code>. The leading <code>@</code> is optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "In <b>authorFeed</b> mode, also include the author's replies (default: original posts, quotes and reposts only).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of records to return across the whole run. Set 0 for no limit (paginate until the source is exhausted). Each record returned is billed — see Pricing in the README.",
                        "default": 100
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword or hashtag to search posts for (used in <b>search</b> mode). Supports Bluesky search operators typed directly into the query, e.g. <code>#ai</code>, <code>\"exact phrase\"</code> — or use the dedicated <b>From author</b>, <b>Mentions author</b> and <b>Language</b> fields below instead of typing <code>from:</code>/<code>mentions:</code>/<code>lang:</code>."
                    },
                    "since": {
                        "title": "Since",
                        "type": "string",
                        "description": "Only return posts created at or after this date (used in <b>search</b> mode). Pick a date, or type a precise ISO 8601 timestamp such as <code>2026-06-01T00:00:00Z</code> for finer control."
                    },
                    "until": {
                        "title": "Until",
                        "type": "string",
                        "description": "Only return posts created before this date (used in <b>search</b> mode). Pick a date, or type a precise ISO 8601 timestamp such as <code>2026-07-01T00:00:00Z</code> for finer control."
                    },
                    "fromAuthor": {
                        "title": "From author",
                        "type": "string",
                        "description": "Only return posts written by this account (used in <b>search</b> mode). Enter a handle, e.g. <code>bsky.app</code> — same as typing <code>from:</code> into a Bluesky search. The leading <code>@</code> is optional."
                    },
                    "mentionsAuthor": {
                        "title": "Mentions author",
                        "type": "string",
                        "description": "Only return posts that mention this account (used in <b>search</b> mode). Enter a handle, e.g. <code>bsky.app</code> — same as typing <code>mentions:</code> into a Bluesky search. The leading <code>@</code> is optional."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Only return posts declared in this language (used in <b>search</b> mode). Two-letter ISO 639-1 code, e.g. <code>en</code>, <code>fr</code>, <code>ja</code>."
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "latest",
                            "top"
                        ],
                        "type": "string",
                        "description": "Ranking for <b>search</b> mode: newest first or by relevance/engagement.",
                        "default": "latest"
                    },
                    "minLikes": {
                        "title": "Min likes",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop posts with fewer likes than this before they are returned (applies to <b>search</b> and <b>authorFeed</b> modes; compares against each post's <code>likeCount</code>). 0 = no filter.",
                        "default": 0
                    },
                    "minReposts": {
                        "title": "Min reposts",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop posts with fewer reposts than this before they are returned (applies to <b>search</b> and <b>authorFeed</b> modes; compares against each post's <code>repostCount</code>). 0 = no filter.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
