# Bluesky Brand Monitor — New Mentions, Keyword & Account Alerts (`prometheusagency/bluesky-brand-monitor`) Actor

Monitor Bluesky for NEW brand mentions, keywords and account posts. Outputs only what's new since the last run, keeps state between runs, and can alert your webhook (Slack, Discord, Zapier, n8n). Run it on a schedule for 24/7 social listening.

- **URL**: https://apify.com/prometheusagency/bluesky-brand-monitor.md
- **Developed by:** [Prometheus Agency](https://apify.com/prometheusagency) (community)
- **Categories:** Social media, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Brand Monitor — New Mentions, Keyword & Account Alerts

**Only what's NEW.** This Actor monitors Bluesky (44M+ users) for new brand mentions, keyword hits
and account posts — and outputs **only the posts that appeared since the last run**. Put it on a
schedule (hourly/daily) and you have 24/7 social listening with zero noise.

### Why this instead of a normal scraper?

A scraper gives you everything, every time — you deduplicate and diff yourself. The Monitor keeps
**persistent state between runs**:

- Run 1: records the baseline (optionally outputs nothing with "baseline only" mode)
- Every next run: outputs **only new posts** and can POST a JSON alert to your **webhook**
  (Slack, Discord, Zapier, Make, n8n)

### What you can monitor

| Source | Login needed? | Typical use |
|---|---|---|
| **Accounts** (handles) | ❌ No | Competitors, influencers, your own brand account |
| **Keywords / brand names** | 🔑 Free app password | Brand mentions, product names, campaign phrases |

### Webhook alert payload

```json
{
  "source": "bluesky-brand-monitor",
  "totalNewMentions": 7,
  "bySource": [
    { "kind": "keyword", "value": "acme", "newMentions": 5,
      "topPost": { "url": "https://bsky.app/...", "text": "...", "author": "user.bsky.social", "likeCount": 12 } }
  ],
  "datasetUrl": "https://api.apify.com/v2/datasets/<id>/items",
  "checkedAt": "2026-07-02T10:00:00.000Z"
}
````

### Set up scheduled monitoring (2 minutes)

1. Configure your keywords and/or accounts in the input.
2. (Keywords only) add your free Bluesky app password: create account at bsky.app →
   **Settings → Privacy and Security → App Passwords**. Never your real password.
3. Save the run as a **Task**, then add a **Schedule** (e.g. every hour).
4. Optional: paste a webhook URL to get pinged only when there's something new.

### Output

Same clean post schema as our [Bluesky Scraper](https://apify.com/prometheusagency/bluesky-scraper)
(text, author, counts, images, links…) plus `monitoredKeyword` / `monitoredAccount` fields, in
JSON/CSV/Excel or via API.

### Pricing that makes sense for monitoring

You pay per **new mention found** — quiet days cost you almost nothing (just the tiny Actor start
event). No flat subscription for a firehose you don't read.

# Actor input Schema

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

Brand names, product names or phrases. Requires a free Bluesky app password (fields below). Leave empty to monitor accounts only.

## `accounts` (type: `array`):

Bluesky handles whose new posts you want to track (competitors, influencers, your own). Works WITHOUT any login.

## `maxPostsPerSource` (type: `integer`):

How many recent posts to check per keyword/account each run. Only NEW ones are output.

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

Two-letter language code for keyword search, e.g. en, es.

## `blueskyIdentifier` (type: `string`):

Your Bluesky handle, e.g. yourname.bsky.social. Only needed when monitoring keywords.

## `blueskyAppPassword` (type: `string`):

App password from bsky.app → Settings → Privacy and Security → App Passwords. NEVER your real password.

## `webhookUrl` (type: `string`):

If set, a JSON summary of new mentions is POSTed here (works with Slack, Discord, Zapier, Make, n8n).

## `firstRunBaselineOnly` (type: `boolean`):

If enabled, the first run just records the current state and outputs nothing; alerts start from the second run. Recommended for scheduled monitoring.

## `requestDelayMs` (type: `integer`):

Politeness delay between API requests.

## Actor input object example

```json
{
  "keywords": [],
  "accounts": [
    "bsky.app"
  ],
  "maxPostsPerSource": 100,
  "firstRunBaselineOnly": false,
  "requestDelayMs": 200
}
```

# 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": [],
    "accounts": [
        "bsky.app"
    ],
    "maxPostsPerSource": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("prometheusagency/bluesky-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": [],
    "accounts": ["bsky.app"],
    "maxPostsPerSource": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("prometheusagency/bluesky-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": [],
  "accounts": [
    "bsky.app"
  ],
  "maxPostsPerSource": 100
}' |
apify call prometheusagency/bluesky-brand-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Brand Monitor — New Mentions, Keyword & Account Alerts",
        "description": "Monitor Bluesky for NEW brand mentions, keywords and account posts. Outputs only what's new since the last run, keeps state between runs, and can alert your webhook (Slack, Discord, Zapier, n8n). Run it on a schedule for 24/7 social listening.",
        "version": "0.1",
        "x-build-id": "VYEpWfNaYVgH2J9mn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prometheusagency~bluesky-brand-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prometheusagency-bluesky-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/prometheusagency~bluesky-brand-monitor/runs": {
            "post": {
                "operationId": "runs-sync-prometheusagency-bluesky-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/prometheusagency~bluesky-brand-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-prometheusagency-bluesky-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": "Brand keywords to monitor",
                        "type": "array",
                        "description": "Brand names, product names or phrases. Requires a free Bluesky app password (fields below). Leave empty to monitor accounts only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "accounts": {
                        "title": "Accounts to monitor",
                        "type": "array",
                        "description": "Bluesky handles whose new posts you want to track (competitors, influencers, your own). Works WITHOUT any login.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerSource": {
                        "title": "Max posts checked per source",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many recent posts to check per keyword/account each run. Only NEW ones are output.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language filter (keywords)",
                        "type": "string",
                        "description": "Two-letter language code for keyword search, e.g. en, es."
                    },
                    "blueskyIdentifier": {
                        "title": "Bluesky handle (only for keywords)",
                        "type": "string",
                        "description": "Your Bluesky handle, e.g. yourname.bsky.social. Only needed when monitoring keywords."
                    },
                    "blueskyAppPassword": {
                        "title": "Bluesky app password (only for keywords)",
                        "type": "string",
                        "description": "App password from bsky.app → Settings → Privacy and Security → App Passwords. NEVER your real password."
                    },
                    "webhookUrl": {
                        "title": "Alert webhook URL (optional)",
                        "type": "string",
                        "description": "If set, a JSON summary of new mentions is POSTed here (works with Slack, Discord, Zapier, Make, n8n)."
                    },
                    "firstRunBaselineOnly": {
                        "title": "First run = baseline only (no output)",
                        "type": "boolean",
                        "description": "If enabled, the first run just records the current state and outputs nothing; alerts start from the second run. Recommended for scheduled monitoring.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between API calls (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Politeness delay between API requests.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```