# Bluesky & Lemmy Brand Monitor (`orbiscribe/open-social-brand-monitor`) Actor

Monitor public Bluesky and Lemmy posts for brand, competitor, keyword, launch, and support mentions using open APIs.

- **URL**: https://apify.com/orbiscribe/open-social-brand-monitor.md
- **Developed by:** [Orbiscribe Labs](https://apify.com/orbiscribe) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 social post matches

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

Monitor brand, competitor, and keyword mentions on Bluesky and Lemmy. This Actor
uses public APIs for open social networks and returns one structured dataset row
per matching public post.

Use it for brand monitoring, launch tracking, competitor mentions, developer
relations, community research, support escalations, and lightweight social
listening without relying on X/Twitter credentials.

### What does this Bluesky and Lemmy monitor do?

Open Social Brand Monitor searches public Bluesky posts through the AT Protocol
API and public Lemmy instances through the Lemmy API. It normalizes results into
one Apify dataset with post text, author handle, source URL, created date,
matched query, and engagement score.

It requires no login, no browser, and no private credentials.

The Actor also writes key-value outputs for scheduled workflows:

- `RUN_SUMMARY`: counts, inputs, deduping, and errors
- `POST_EXPORT`: all emitted social post matches
- `BUYER_BRIEF`: a short Markdown brief by platform, query, and engagement
- `SLACK_ALERTS`: compact alert objects for webhook or chat workflows

### What data can you extract?

| Field | Description |
| --- | --- |
| `platform` | Bluesky or Lemmy |
| `query` | Keyword or phrase that matched |
| `matchedTerms` | Matched terms found in the post |
| `text` | Public post text |
| `authorHandle` | Public handle or username |
| `authorDisplayName` | Display name when available |
| `createdAt` | Post creation timestamp |
| `url` | Public post URL |
| `engagement` | Replies, reposts, likes, score, or comments when available |
| `engagementScore` | Combined engagement number for sorting |
| `sourceApi` | Source API used for the result |

### Quick start

1. Add brand, product, competitor, or category keywords.
2. Choose `bluesky`, `lemmy`, or both.
3. For Lemmy, choose instances such as `lemmy.world`.
4. Set `sinceHours`, `maxItemsPerQuery`, and `maxResults`.
5. Start small, then schedule recurring monitoring.

Example searches:

- your company or product name
- competitor names
- launch keywords
- error messages or complaints
- developer questions about your category

### Input example

```json
{
  "keywords": ["Apify", "developer tools", "web scraping"],
  "platforms": ["bluesky", "lemmy"],
  "lemmyInstances": ["lemmy.world"],
  "sinceHours": 168,
  "maxItemsPerQuery": 25,
  "maxResults": 200
}
````

### Output example

```json
{
  "platform": "bluesky",
  "query": "developer tools",
  "matchedTerms": ["developer tools"],
  "id": "at://did:plc:demo/app.bsky.feed.post/demo",
  "text": "Looking for reliable developer tools that can monitor public data sources and send structured alerts.",
  "authorHandle": "demo.bsky.social",
  "authorDisplayName": "Demo Researcher",
  "createdAt": "2026-05-10T12:00:00.000Z",
  "url": "https://bsky.app/profile/demo.bsky.social/post/demo",
  "engagement": {
    "replies": 2,
    "reposts": 1,
    "likes": 8
  },
  "engagementScore": 11,
  "sourceApi": "Bluesky searchPosts"
}
```

### Pricing

This Actor uses pay-per-event pricing. Dry-run examples are not charged. Apify free-plan users get the first 25 social post match records without this Actor's custom event charge; after that, normal pay-per-event pricing and the user's run spending limit apply.

| Event | Price | What counts |
| --- | --- | --- |
| `social-post-match` | `$0.001` | One matched public Bluesky or Lemmy post written to the dataset |

That is `$1 per 1,000` emitted social post matches, plus normal Apify platform
usage. It is designed for daily monitoring across several saved searches.

### Common use cases

- Track brand and product mentions after a launch.
- Watch competitor comparisons on open social networks.
- Find developer questions and complaints in your category.
- Monitor support issues that mention your product.
- Build a daily social-listening feed for Slack, email, Sheets, or Airtable.

### Limits and compliance

The Actor only uses public API data. It does not log in, bypass access controls,
scrape private posts, enrich contacts, harvest followers, or archive deleted
content.

Use the output for monitoring and research, not spam, harassment, sensitive
profiling, or context-free claims about individual users.

# Actor input Schema

## `keywords` (type: `array`):

Brand, competitor, hashtag, topic, or phrase searches.

## `platforms` (type: `array`):

Public networks to search. Mastodon is intentionally omitted from defaults because unauthenticated search varies by instance.

## `lemmyInstances` (type: `array`):

Public Lemmy instances to search.

## `sinceHours` (type: `integer`):

Only keep posts created in the last N hours where the source provides timestamps.

## `maxItemsPerQuery` (type: `integer`):

Maximum posts fetched per keyword and platform.

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

Maximum total records written to the dataset.

## `dryRun` (type: `boolean`):

Use bundled example records without calling external APIs.

## Actor input object example

```json
{
  "keywords": [
    "Apify",
    "AI agents",
    "web scraping"
  ],
  "platforms": [
    "bluesky",
    "lemmy"
  ],
  "lemmyInstances": [
    "lemmy.world"
  ],
  "sinceHours": 168,
  "maxItemsPerQuery": 25,
  "maxResults": 200,
  "dryRun": false
}
```

# Actor output Schema

## `results` (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 = {
    "keywords": [
        "Apify",
        "AI agents",
        "web scraping"
    ],
    "platforms": [
        "bluesky",
        "lemmy"
    ],
    "lemmyInstances": [
        "lemmy.world"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("orbiscribe/open-social-brand-monitor").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 = {
    "keywords": [
        "Apify",
        "AI agents",
        "web scraping",
    ],
    "platforms": [
        "bluesky",
        "lemmy",
    ],
    "lemmyInstances": ["lemmy.world"],
}

# Run the Actor and wait for it to finish
run = client.actor("orbiscribe/open-social-brand-monitor").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 '{
  "keywords": [
    "Apify",
    "AI agents",
    "web scraping"
  ],
  "platforms": [
    "bluesky",
    "lemmy"
  ],
  "lemmyInstances": [
    "lemmy.world"
  ]
}' |
apify call orbiscribe/open-social-brand-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=orbiscribe/open-social-brand-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky & Lemmy Brand Monitor",
        "description": "Monitor public Bluesky and Lemmy posts for brand, competitor, keyword, launch, and support mentions using open APIs.",
        "version": "0.1",
        "x-build-id": "aP2RAuBwNdwc23o0p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/orbiscribe~open-social-brand-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-orbiscribe-open-social-brand-monitor",
                "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/orbiscribe~open-social-brand-monitor/runs": {
            "post": {
                "operationId": "runs-sync-orbiscribe-open-social-brand-monitor",
                "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/orbiscribe~open-social-brand-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-orbiscribe-open-social-brand-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Brand, competitor, hashtag, topic, or phrase searches.",
                        "default": [
                            "Apify",
                            "AI agents",
                            "web scraping"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "platforms": {
                        "title": "Platforms",
                        "type": "array",
                        "description": "Public networks to search. Mastodon is intentionally omitted from defaults because unauthenticated search varies by instance.",
                        "default": [
                            "bluesky",
                            "lemmy"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "lemmyInstances": {
                        "title": "Lemmy instances",
                        "type": "array",
                        "description": "Public Lemmy instances to search.",
                        "default": [
                            "lemmy.world"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sinceHours": {
                        "title": "Since hours",
                        "minimum": 1,
                        "maximum": 8760,
                        "type": "integer",
                        "description": "Only keep posts created in the last N hours where the source provides timestamps.",
                        "default": 168
                    },
                    "maxItemsPerQuery": {
                        "title": "Max items per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum posts fetched per keyword and platform.",
                        "default": 25
                    },
                    "maxResults": {
                        "title": "Max total results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum total records written to the dataset.",
                        "default": 200
                    },
                    "dryRun": {
                        "title": "Dry run",
                        "type": "boolean",
                        "description": "Use bundled example records without calling external APIs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
