# Bluesky Trend Intelligence (`skootle/bluesky-trend-intelligence`) Actor

Official Bluesky and AT Protocol post search with explainable trend velocity, topic clusters, author concentration, agent-ready summaries, API output, scheduling, monitoring, and integrations.

- **URL**: https://apify.com/skootle/bluesky-trend-intelligence.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** Social media, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 bluesky intelligence output records

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<!-- skootle:growth-loop-hook -->
## Bluesky Trend Intelligence

![Bluesky Trend Intelligence hero](https://raw.githubusercontent.com/kesjam/skootle-actors-assets/main/heroes/bluesky-trend-intelligence.png)

### TL;DR

Search public Bluesky posts through the official AT Protocol AppView, then receive normalized `POST` records plus one decision-ready `SUMMARY`. Every post includes `authorHandle`, `text`, `createdAt`, `likeCount`, `repostCount`, `replyCount`, `quoteCount`, `engagementTotal`, `engagementVelocityPerHour`, `breakoutScore`, `fieldCompletenessScore`, `confidence`, `sourceUrl`, and `agentMarkdown`. The summary adds ranked topics, author concentration, top breakout posts, source status, and query provenance.

Use it when a raw post export is not enough. It helps social teams spot accelerating conversations, researchers compare themes, agencies monitor client categories, founders watch market language, and agents consume evidence-linked records without guessing what an empty result means.

Run it in four ways:

1. Enter keywords or hashtags in the Apify Console.
2. Call the Actor through the Apify API from your application.
3. Schedule recurring searches to build a monitoring history.
4. Connect the dataset to webhooks, Make, Zapier, n8n, Sheets, BI tools, or an agent workflow.

<!-- skootle:review-cta -->
If this Actor saves research time, [leave a review](https://apify.com/skootle/bluesky-trend-intelligence/reviews). Reviews help prioritize the next buyer-facing improvements.

### What does Bluesky Trend Intelligence do?

The Actor searches the public Bluesky network with the official `app.bsky.feed.searchPosts` endpoint. It does not need a Bluesky login, a proxy, a browser, or a buyer-supplied API key. It converts public AppView responses into stable, typed records designed for monitoring and downstream analysis.

A raw scraper tells you what posts exist. This Actor also explains what is moving:

- **Engagement total** combines likes, reposts, replies, and quotes as a number.
- **Engagement velocity per hour** divides observed engagement by post age, with a bounded floor for very new posts.
- **Breakout score** combines log-scaled engagement with velocity on a 0 to 100 scale.
- **Topic clusters** rank repeated meaningful words and preserve evidence record IDs.
- **Author concentration** shows which handles account for the most posts and engagement.
- **Top breakouts** provide direct public URLs for the strongest current signals.
- **Source diagnostics** distinguish a valid no-match from transport, HTTP, malformed JSON, and source-shape failures.

The scores are explainable signals, not predictions. Use the linked posts and normalized component fields when a decision needs human review.

### Why monitor Bluesky now?

Bluesky conversations move quickly and often surface technical, media, creator, policy, startup, and community signals before they are reflected in slower reports. The public AT Protocol makes the source unusually integration-friendly, but teams still need normalization, deduplication, ranking, provenance, and honest failure behavior before the data is useful in a recurring workflow.

Common buyer questions include:

- Which posts around a category are gaining engagement fastest?
- Which terms repeatedly appear in the current result set?
- Are a few accounts dominating the conversation?
- What language should a content brief quote or respond to?
- Did a scheduled search return no matches, or did the source fail?
- Can the output go directly into an agent without a cleanup step?

This Actor answers those questions with typed fields and source links rather than an unstructured page dump.

### What data do I get?

#### `POST` records

Each normalized post includes:

- `schemaVersion`: output contract version.
- `recordType`: always `POST` for post rows.
- `id`: stable SHA-256-derived record ID based on the AT Protocol URI.
- `query`: the buyer query that produced the row.
- `platform`: `bluesky`.
- `source`: the public AT Protocol AppView label.
- `sourceUrl`: a browser-readable public Bluesky post URL.
- `uri` and `cid`: AT Protocol identity and content address when exposed.
- `retrievedAt`, `createdAt`, and `indexedAt`: ISO 8601 timestamps.
- `authorDid`, `authorHandle`, and `authorDisplayName`.
- `text` and `language`.
- `isReply`: whether the post replies to another post.
- `likeCount`, `repostCount`, `replyCount`, and `quoteCount`.
- `engagementTotal`: numeric sum of the four engagement counters.
- `engagementVelocityPerHour`: age-normalized current engagement signal.
- `breakoutScore`: explainable 0 to 100 current breakout signal.
- `fieldCompletenessScore`: percentage of core fields present.
- `confidence`: bounded confidence based on completeness.
- `agentMarkdown`: a compact evidence block ready for retrieval or an agent prompt.

#### `SUMMARY` record

Every successful run ends with exactly one summary. It includes:

- Exact input queries and sort order.
- `count` and numeric mirror `countNumeric`.
- Number of unique authors.
- `sourceStatus` as `ok` or `no_match`.
- Ranked `topics` with counts, shares, and evidence IDs.
- `topAuthors` with post counts and total engagement.
- `topBreakouts` with scores, velocity, handles, and source URLs.
- `errors: []` for a healthy completed source read.
- A query fingerprint for stable monitoring and audit joins.
- `agentMarkdown` with the leading topics and strongest breakout signals.

The same briefing is saved as `AGENT_BRIEFING.md` in the run key-value store.

### How do I search Bluesky posts?

Enter one to ten queries. A query can be a phrase, keyword, brand, product category, person, hashtag, domain term, or Boolean-style expression supported by Bluesky search. Keep queries focused when you want interpretable topic shares.

Recommended inputs:

```json
{
  "queries": ["artificial intelligence", "AI agents"],
  "sort": "top",
  "language": "en",
  "maxResultsPerQuery": 25,
  "minEngagement": 0,
  "includeReplies": false
}
````

For a recency-focused monitoring run:

```json
{
  "queries": ["small business automation", "workflow automation"],
  "sort": "latest",
  "since": "2026-07-20T00:00:00Z",
  "language": "en",
  "maxResultsPerQuery": 50,
  "minEngagement": 2,
  "includeReplies": false
}
```

#### Input reference

| Field | Type | Default | Purpose |
|---|---:|---:|---|
| `queries` | string array | required | One to ten public Bluesky searches. |
| `sort` | `top` or `latest` | `top` | Relevance/engagement or recency order. |
| `since` | ISO date or date-time | unset | Lower publication-time bound. |
| `until` | ISO date or date-time | unset | Upper publication-time bound. |
| `language` | BCP-47 string | `en` | Optional language filter passed to AppView. |
| `maxResultsPerQuery` | integer 1 to 100 | 25 | Hard result cap per query. |
| `minEngagement` | nonnegative integer | 0 | Client-side minimum combined engagement. |
| `includeReplies` | boolean | false | Include or exclude reply posts. |

The Actor rejects an invalid date range where `since` is later than `until`. Caps are enforced before output grows beyond the requested scope.

### How is the breakout score calculated?

The score is intentionally explainable. It combines:

1. Log-scaled total engagement, so one huge account does not make every smaller signal invisible.
2. Engagement velocity per hour, which helps a newer active post compete with an older post that accumulated engagement slowly.
3. A hard 0 to 100 bound for predictable sorting and dashboards.

The underlying numbers remain in the record. A buyer can ignore `breakoutScore` and use `engagementTotal`, `engagementVelocityPerHour`, `createdAt`, and the direct source URL instead. Nothing depends on a hidden model or an opaque prompt.

This is not a forecast of future virality. It is a current signal computed from the public counters returned at retrieval time.

### Worked example 1: find an accelerating AI conversation

Input:

```json
{
  "queries": ["AI agents"],
  "sort": "latest",
  "maxResultsPerQuery": 25,
  "minEngagement": 1
}
```

Representative normalized output:

```json
{
  "recordType": "POST",
  "query": "AI agents",
  "authorHandle": "builder.bsky.social",
  "text": "A practical agent needs tools, memory, and a clear approval boundary.",
  "engagementTotal": 38,
  "engagementVelocityPerHour": 12.667,
  "breakoutScore": 90.476,
  "fieldCompletenessScore": 100,
  "confidence": 0.96,
  "sourceUrl": "https://bsky.app/profile/builder.bsky.social/post/example"
}
```

Decision use: sort by velocity, open the linked evidence, then quote or brief only after reading the public post in context.

### Worked example 2: compare category language

Input:

```json
{
  "queries": ["customer support automation", "AI customer service"],
  "sort": "top",
  "maxResultsPerQuery": 40,
  "includeReplies": false
}
```

The summary might rank terms such as `support`, `agent`, `workflow`, `ticket`, and `response`. Each topic carries up to five evidence IDs. This supports a content brief without claiming that a repeated word equals customer demand.

Decision use: compare topic counts and shares, then inspect the highest-engagement evidence rows before changing messaging.

### Worked example 3: monitor a brand mention

```json
{
  "queries": ["examplebrand"],
  "sort": "latest",
  "since": "2026-07-21T00:00:00Z",
  "maxResultsPerQuery": 100,
  "includeReplies": true
}
```

Schedule the run hourly or daily. Store each dataset ID with its retrieval time. Use `uri` as the durable post identity and `queryFingerprint` to join comparable runs.

Decision use: alert only when a new URI appears or engagement velocity crosses your own threshold. This Actor does not send public replies or mutate Bluesky.

### Worked example 4: identify concentrated voices

A summary can show that three authors account for most engagement in a result set. That prevents a team from mistaking a concentrated conversation for broad consensus.

Use `topAuthors[].posts` and `topAuthors[].engagement` together. A prolific low-engagement author and a single high-engagement author are different signals.

Decision use: diversify source review before presenting a market claim.

### Worked example 5: build an agent research packet

Run several narrow queries, then feed only these fields into retrieval:

```json
{
  "id": "stable-record-id",
  "query": "open source agents",
  "authorHandle": "researcher.bsky.social",
  "text": "Public post text",
  "createdAt": "2026-07-21T10:00:00.000Z",
  "engagementTotal": 18,
  "breakoutScore": 74.3,
  "sourceUrl": "https://bsky.app/profile/researcher.bsky.social/post/example",
  "agentMarkdown": "## @researcher.bsky.social ..."
}
```

Decision use: require the agent to cite `sourceUrl` and distinguish the author’s statement from its own interpretation.

### Worked example 6: prove a valid no-match

A narrow query or time window can legitimately return no public posts. The Actor returns a `SUMMARY` with:

```json
{
  "recordType": "SUMMARY",
  "count": 0,
  "countNumeric": 0,
  "uniqueAuthors": 0,
  "sourceStatus": "no_match",
  "topics": [],
  "topAuthors": [],
  "topBreakouts": [],
  "errors": []
}
```

That is different from a source outage. HTTP failures, malformed JSON, and payload-shape drift fail the run and write `DEBUG_ZERO_PARSE.json` with bounded diagnostic evidence.

### How do scheduled monitoring workflows work?

Apify schedules can run this Actor at a recurring interval. Recommended monitoring pattern:

1. Keep the query set and sort mode stable.
2. Use `since` for the observation window you actually need.
3. Save the dataset ID and run timestamp.
4. Join rows by `uri` or stable `id`.
5. Compare new posts and engagement counters outside the Actor.
6. Route only evidence-backed changes to alerts, dashboards, or agents.

The Actor itself performs read-only collection. It does not like, repost, reply, follow, message, or change any Bluesky account.

### Can I use the API and integrations?

Yes. The Actor works from the Console, Apify API, schedules, tasks, webhooks, and standard dataset exports. Output is available as JSON, CSV, XML, Excel, RSS, and the other formats supported by Apify datasets.

Useful integration patterns:

- Push new high-velocity rows into Slack or Teams through a webhook workflow.
- Append normalized records to Google Sheets for editorial review.
- Send datasets to BigQuery, Snowflake, PostgreSQL, or a warehouse pipeline.
- Trigger n8n, Make, or Zapier after a successful run.
- Feed `agentMarkdown` and source URLs into a retrieval or research agent.
- Build a lightweight category-monitoring API over saved datasets.

### Why choose this Actor?

The leading general Bluesky scrapers are strong at broad extraction. This Actor is deliberately narrower and decision-focused.

| Capability | Bluesky Trend Intelligence | Typical raw scraper |
|---|---|---|
| Official public AT Protocol source | Yes | Often |
| Login or proxy required | No | Usually no |
| Stable typed post schema | Yes | Varies |
| Engagement velocity per hour | Yes | Usually no |
| Explainable breakout score | Yes | Usually no |
| Ranked topic evidence IDs | Yes | Usually no |
| Author concentration summary | Yes | Usually no |
| Agent-ready Markdown per row | Yes | Usually no |
| Honest no-match contract | Yes | Varies |
| Debug artifact on source drift | Yes | Varies |
| Read-only behavior | Yes | Varies by product |

Choose a broad scraper when you need followers, DMs, complete threads, or every general extraction mode in one run. Choose this Actor when you need search-driven public-post intelligence, monitoring records, source evidence, and explainable ranking.

### Pricing

Launch pricing is pay per event:

- Actor start: `$0.01`.
- Dataset item: `$0.003`, equal to `$3 per 1,000` emitted records before tier discounts.
- Buyer-controlled run cap: up to `$5`.
- Apify platform usage passthrough: off.

A dataset item is a normalized post or the run summary. The key-value-store briefing is not a second dataset charge. Small bounded searches stay inexpensive, while the run cap limits larger batches.

Pricing is positioned for intelligence output rather than the cheapest possible raw extraction. The listing exposes the score components and direct source links so buyers can judge the added value.

### Reliability, empty results, and diagnostics

A successful run means the official AppView responded with valid JSON matching the expected post shape. Outcomes are explicit:

- `sourceStatus: ok`: one or more normalized posts passed filters.
- `sourceStatus: no_match`: the source was healthy and no posts passed the query and filters.
- Failed run: transport error, non-2xx HTTP status, malformed JSON, payload-shape change, or invalid input.

On a source or parser failure, the Actor writes a bounded `DEBUG_ZERO_PARSE.json` artifact with stage, message, URL, HTTP status when available, a limited response snippet, and retrieval time. It does not turn a blocked or malformed response into a billable-looking empty success.

Public network data can change or be removed. Engagement counts are observations at retrieval time. Deleted posts and moderation decisions remain controlled by Bluesky and the relevant Personal Data Server.

### Tutorial: create a daily Bluesky category brief

1. Open the Actor and enter two to five focused category queries.
2. Choose `latest` when you care about current posts or `top` for the strongest result set.
3. Set `since` to the beginning of your monitoring window.
4. Keep `maxResultsPerQuery` between 25 and 100.
5. Set `minEngagement` only if low-interaction posts are noise for your use case.
6. Run once and inspect the `SUMMARY` plus direct source links.
7. Save the configuration as a task.
8. Add an Apify schedule.
9. Connect the dataset or webhook to your review destination.
10. Compare stable post IDs between runs before raising an alert.

A safe alert contains the query, post URL, observed counters, retrieval time, and the rule that triggered it. Avoid presenting a breakout score as a guaranteed future outcome.

### FAQ

#### Does this need a Bluesky login?

No. It uses the public Bluesky AppView for public post search. It does not read private messages or private account data.

#### Does it use an unofficial scraper or browser automation?

No. The acquisition path is HTTP-only against the public AT Protocol AppView. That reduces cost, startup time, and anti-bot fragility.

#### Can it scrape followers or complete user feeds?

Not in this product. The Actor is optimized for search-driven trend and conversation intelligence. Use a broad profile or follower scraper when that is the required outcome.

#### Can it search hashtags?

Yes. Include the hashtag or term in `queries`. Search behavior ultimately follows the public Bluesky endpoint.

#### Can I include replies?

Yes. Set `includeReplies` to `true`. The default is false so top-level conversation signals are easier to interpret.

#### How is engagement calculated?

`engagementTotal` is likes plus reposts plus replies plus quotes. All component counters remain available separately.

#### Is the breakout score AI-generated?

No. It is deterministic math over engagement, post age, and a bounded logarithmic scale. The components are visible in every row.

#### Why can two queries return the same post only once?

The Actor deduplicates on the AT Protocol URI. The retained row preserves the query associated with the first accepted occurrence in the input order.

#### What does `fieldCompletenessScore` mean?

It measures presence of core identity, author, text, and time fields. It is a data-completeness indicator, not a truth score.

#### What happens if Bluesky changes its response shape?

The run fails closed and writes diagnostic evidence. It does not silently emit zero rows from an unexpected payload.

#### Can a no-match run succeed?

Yes. A healthy source with no matching posts returns an explicit zero-count summary with `errors: []` and `sourceStatus: no_match`.

#### Can I use the output in an AI agent?

Yes. Use typed fields, `agentMarkdown`, query fingerprints, and direct source URLs. Require source citation and keep interpretations separate from observed post content.

#### Can I schedule monitoring?

Yes. Use Apify schedules or tasks. Keep comparable input stable and join rows by `uri` or `id`.

#### Does this Actor take actions on Bluesky?

No. It is read-only. It never posts, replies, likes, reposts, follows, or sends messages.

#### Is this affiliated with Bluesky?

No. This independent Actor uses publicly available AT Protocol data. Bluesky and AT Protocol names identify the data source. No endorsement or partnership is implied.

### Legal and responsible use

Use the Actor only for lawful purposes and comply with applicable privacy, data protection, intellectual-property, employment, marketing, and platform rules. Public availability does not eliminate a buyer’s obligations. Minimize retained personal data, establish a lawful purpose, honor deletion or suppression duties where applicable, and avoid sensitive profiling or automated high-impact decisions without appropriate review.

Do not use output for harassment, stalking, discrimination, doxxing, credential discovery, or attempts to bypass platform controls. Do not infer protected traits from posts or profile metadata. The Actor collects public post search results and performs no account action.

Data may be revised, moderated, or deleted after retrieval. Preserve `retrievedAt` and `sourceUrl`, and re-check the source before making a consequential claim.

### Support and feedback

Use the Actor **Issues** tab for reproducible bugs. Include the run ID, a redacted input, expected behavior, observed behavior, and whether the failure affected all queries or one query. Never post passwords, API tokens, private exports, or personal information that is not necessary to reproduce the issue.

Feature requests are welcome. The most useful requests describe the buyer decision, required fields, desired schedule, expected volume, and output destination.

### Related Skootle Actors

Pair this Actor with:

- **Google Trends Intelligence** for search-interest direction, momentum, and related-query evidence.
- **Website SEO Audit Intelligence** for technical and content findings on sites discovered through social research.
- **Website Tech Stack Intelligence** for explainable technology fingerprints and lead qualification.

Use Bluesky Trend Intelligence for the conversation signal, then use a sibling Actor only when its separate data source supports the next decision.

### Output contract summary

- One stable `POST` row per unique AT Protocol URI that passes filters.
- Exactly one `SUMMARY` row per healthy run.
- One `AGENT_BRIEFING.md` key-value record.
- ISO 8601 timestamps.
- Numeric engagement mirrors.
- Stable IDs and query fingerprint.
- Direct public provenance URLs.
- No generic untyped primary output.
- No silent success after source or parser failure.
- No external messages or platform mutations.

# Actor input Schema

## `queries` (type: `array`):

Keywords, phrases, hashtags, or domain terms to search through the public Bluesky AppView.

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

Top ranks by relevance and engagement. Latest prioritizes recent posts.

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

Optional ISO date or date-time lower bound.

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

Optional ISO date or date-time upper bound.

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

Optional BCP-47 language code such as en.

## `maxResultsPerQuery` (type: `integer`):

Hard cap for each query.

## `minEngagement` (type: `integer`):

Minimum combined likes, reposts, replies, and quotes.

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

Include posts that reply to another post.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence",
    "small business"
  ],
  "sort": "top",
  "language": "en",
  "maxResultsPerQuery": 25,
  "minEngagement": 0,
  "includeReplies": false
}
```

# Actor output Schema

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

No description

## `briefing` (type: `string`):

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("skootle/bluesky-trend-intelligence").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("skootle/bluesky-trend-intelligence").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 '{}' |
apify call skootle/bluesky-trend-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Trend Intelligence",
        "description": "Official Bluesky and AT Protocol post search with explainable trend velocity, topic clusters, author concentration, agent-ready summaries, API output, scheduling, monitoring, and integrations.",
        "version": "1.0",
        "x-build-id": "3FbUZH919EXN7jCu6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skootle~bluesky-trend-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skootle-bluesky-trend-intelligence",
                "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/skootle~bluesky-trend-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-skootle-bluesky-trend-intelligence",
                "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/skootle~bluesky-trend-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-skootle-bluesky-trend-intelligence",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "minItems": 1,
                        "maxItems": 10,
                        "type": "array",
                        "description": "Keywords, phrases, hashtags, or domain terms to search through the public Bluesky AppView.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 120
                        },
                        "default": [
                            "artificial intelligence",
                            "small business"
                        ]
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "top",
                            "latest"
                        ],
                        "type": "string",
                        "description": "Top ranks by relevance and engagement. Latest prioritizes recent posts.",
                        "default": "top"
                    },
                    "since": {
                        "title": "Posted since",
                        "type": "string",
                        "description": "Optional ISO date or date-time lower bound."
                    },
                    "until": {
                        "title": "Posted until",
                        "type": "string",
                        "description": "Optional ISO date or date-time upper bound."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Optional BCP-47 language code such as en.",
                        "default": "en"
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum posts per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Hard cap for each query.",
                        "default": 25
                    },
                    "minEngagement": {
                        "title": "Minimum engagement",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Minimum combined likes, reposts, replies, and quotes.",
                        "default": 0
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "Include posts that reply to another post.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
