# Tech Community Monitor — HN Brand & Keyword Tracker (`vertaizen/tech-community-monitor`) Actor

Track brand, product & keyword mentions on Hacker News in real time. Social listening & brand monitoring via the open HN API — no scraping, no blocking. Monitor mode returns only NEW mentions for alerts.

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

## Pricing

from $2.00 / 1,000 mentions

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

## Tech Community Monitor — Track Your Brand on Hacker News

**Tech Community Monitor** is a fast, reliable **social listening** and **brand monitoring** tool for tech companies. It tracks every time your **brand, product, competitor or keyword is mentioned on Hacker News** — stories *and* comments — so marketers, founders and product managers never miss a conversation. Built on **official, open, unauthenticated APIs** (the Hacker News Algolia Search API), there is **no scraping, no browser, no proxies and nothing to get blocked**. Enable **monitor mode** and it becomes a real-time **Hacker News tracking** and **mention alerting** engine: each scheduled run returns only the mentions that appeared since the last run — perfect for **brand mention alerts**, competitor intelligence and lead generation.

If you care about **HN brand monitoring**, **keyword tracking**, **developer-community social listening**, or turning Hacker News chatter into **buying signals**, this actor is for you.

### Why this actor is reliable (and G2/Trustpilot scrapers are not)

Many "monitoring" actors scrape sites protected by WAFs and anti-bot systems, so they break constantly. This actor is different: it talks **only to the public, open Hacker News Algolia API** — the same API that powers HN's own search. It is officially exposed, unauthenticated, fast, and reliable from anywhere. **No CAPTCHAs, no IP blocks, no fragile HTML parsing.**

### What you get for each mention

```json
{
  "keyword": "apify",
  "source": "hackernews",
  "itemType": "story",
  "itemId": "48733650",
  "title": "10x more tools on x402",
  "text": null,
  "author": "jancurn",
  "points": 128,
  "numComments": 42,
  "url": "https://blog.apify.com/introducing-x402-agentic-payments/",
  "createdAt": "2026-06-30T14:58:31Z",
  "isNew": true,
  "scrapedAt": "2026-07-02T09:00:00Z"
}
````

For **comments**, `itemType` is `"comment"`, `text` holds the comment body, `title` holds the parent story title, and `url` is the HN permalink to the comment (`https://news.ycombinator.com/item?id=<id>`).

### How to use it

1. **Add keywords** — your brand, product, competitors, or any topic (e.g. `apify`, `your-startup`, `postgres`).
2. **Pick what to search** — stories (default on), comments (default off), or both.
3. **Set the time range** — e.g. last 7, 30 or 90 days.
4. **(Optional) Filter noise** — set `minPoints` to only surface stories above a signal threshold.
5. **(Optional) Enable monitor mode** — and schedule the actor (e.g. hourly or daily). Each run returns only NEW mentions per keyword. Wire a **webhook** to push new mentions straight to Slack, email, or your CRM.

### Use cases

- **Brand mention alerts** — get notified the moment your product is discussed on Hacker News.
- **Competitor launch tracking** — watch for competitor Show HN posts and the discussion around them.
- **Show HN tracking** — monitor your niche for new launches and gauge community reception.
- **Lead generation** — catch "looking for", "recommend a", or "alternatives to" threads where prospects are actively seeking a tool like yours.
- **PR & reputation monitoring** — surface criticism or praise early, in comments as well as stories.
- **AI agents via MCP** — flat input and clean JSON output make this a drop-in tool for LLM pipelines and AI agents through the Apify MCP server.

### Pricing

**Pay per mention** delivered — no subscription, no minimum. You only pay for the mentions actually pushed to your dataset. Keywords with zero results are never charged.

### FAQ

#### Which sources does it monitor?

Today it monitors **Hacker News** (stories and comments) via the open HN Algolia Search API — the fast, reliable, unblocked core. The architecture is source-pluggable, so additional open communities can be added over time without changing how you use it.

#### How does monitor mode and webhook alerting work?

With `monitorMode` enabled, the actor keeps a per-keyword record of previously seen mention IDs in a persistent named key-value store (`TECH-MONITOR-STATE`). On each run it compares the current mentions against that record and outputs only the new ones (`isNew: true`). The first run for a keyword is a **baseline** (it records what already exists and pushes nothing), so subsequent scheduled runs surface only genuine new activity. Attach an Apify **webhook** to the run to forward new mentions to Slack, email, a CRM, or any endpoint the moment they appear.

#### What time range can I use?

Anywhere from **1 to 365 days** via `timeRangeDays`. Only mentions created within that window are returned.

#### How does deduplication work?

Every mention has a stable, immutable ID (the HN `objectID`). The actor dedupes within a run (the same item can appear across paginated pages or across the story and comment queries) and, in monitor mode, across runs — so you never see the same mention twice.

#### Is this legal?

Yes. The actor reads a **public, official, open API** (the Hacker News Algolia Search API) that requires no login and exposes no private data. It is the same API that powers Hacker News' own search. There is no scraping, no rate-limit abuse, and no personal data collection.

#### How reliable is it?

Very. Because it uses **official open APIs rather than scraping**, there are no CAPTCHAs, WAFs, IP blocks, or brittle HTML selectors to break. Requests are simple JSON `GET`s that succeed from anywhere, which is exactly why this actor works live where WAF-protected review-site scrapers do not.

#### Can AI agents use this actor?

Absolutely. The input schema is flat and agent-friendly, and every Apify actor is consumable via the **Apify MCP server**, so AI agents can call this as a tool to monitor tech communities autonomously.

# Actor input Schema

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

Brands, products, competitors or keywords to search for across tech communities (case-insensitive). Examples: `apify`, `your-startup`, `postgres`.

## `sources` (type: `array`):

Which communities to search. Currently supports the Hacker News open Algolia API — the fast, reliable, unblocked core. More sources can be added over time.

## `searchStories` (type: `boolean`):

Include Hacker News stories (posts, Show HN, Ask HN, submitted links).

## `searchComments` (type: `boolean`):

Include Hacker News comments that mention your keyword. Great for catching organic discussion and buying signals inside threads.

## `timeRangeDays` (type: `integer`):

Only return mentions created within the last N days.

## `maxResultsPerKeyword` (type: `integer`):

Safety cap on the number of mentions returned per keyword.

## `monitorMode` (type: `boolean`):

When enabled, the actor remembers previously seen mentions per keyword and only outputs mentions that appeared since the last run. Ideal for scheduled runs with webhook alerting (Slack, email, CRM).

## `minPoints` (type: `integer`):

Filter out low-signal stories below this HN points threshold. Comments have no points and are treated as 0 (only included when this is 0).

## `exactMatch` (type: `boolean`):

HN search is typo-tolerant (e.g. "shopify" can return "spotify"). When on, only items where the keyword appears as a whole word in the title/text are returned — avoids false positives for brand monitoring. Turn off for broader/fuzzy discovery.

## Actor input object example

```json
{
  "keywords": [
    "apify"
  ],
  "sources": [
    "hackernews"
  ],
  "searchStories": true,
  "searchComments": false,
  "timeRangeDays": 7,
  "maxResultsPerKeyword": 100,
  "monitorMode": false,
  "minPoints": 0,
  "exactMatch": true
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vertaizen/tech-community-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"] }

# Run the Actor and wait for it to finish
run = client.actor("vertaizen/tech-community-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"
  ]
}' |
apify call vertaizen/tech-community-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tech Community Monitor — HN Brand & Keyword Tracker",
        "description": "Track brand, product & keyword mentions on Hacker News in real time. Social listening & brand monitoring via the open HN API — no scraping, no blocking. Monitor mode returns only NEW mentions for alerts.",
        "version": "1.0",
        "x-build-id": "aCrWNNXEbwcY9fUIE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vertaizen~tech-community-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vertaizen-tech-community-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/vertaizen~tech-community-monitor/runs": {
            "post": {
                "operationId": "runs-sync-vertaizen-tech-community-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/vertaizen~tech-community-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-vertaizen-tech-community-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords / brands to track",
                        "type": "array",
                        "description": "Brands, products, competitors or keywords to search for across tech communities (case-insensitive). Examples: `apify`, `your-startup`, `postgres`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Which communities to search. Currently supports the Hacker News open Algolia API — the fast, reliable, unblocked core. More sources can be added over time.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hackernews"
                            ],
                            "enumTitles": [
                                "Hacker News"
                            ]
                        },
                        "default": [
                            "hackernews"
                        ]
                    },
                    "searchStories": {
                        "title": "Search stories",
                        "type": "boolean",
                        "description": "Include Hacker News stories (posts, Show HN, Ask HN, submitted links).",
                        "default": true
                    },
                    "searchComments": {
                        "title": "Search comments",
                        "type": "boolean",
                        "description": "Include Hacker News comments that mention your keyword. Great for catching organic discussion and buying signals inside threads.",
                        "default": false
                    },
                    "timeRangeDays": {
                        "title": "Time range (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only return mentions created within the last N days.",
                        "default": 7
                    },
                    "maxResultsPerKeyword": {
                        "title": "Max results per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Safety cap on the number of mentions returned per keyword.",
                        "default": 100
                    },
                    "monitorMode": {
                        "title": "Monitor mode — only NEW mentions",
                        "type": "boolean",
                        "description": "When enabled, the actor remembers previously seen mentions per keyword and only outputs mentions that appeared since the last run. Ideal for scheduled runs with webhook alerting (Slack, email, CRM).",
                        "default": false
                    },
                    "minPoints": {
                        "title": "Minimum points",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter out low-signal stories below this HN points threshold. Comments have no points and are treated as 0 (only included when this is 0).",
                        "default": 0
                    },
                    "exactMatch": {
                        "title": "Exact keyword match",
                        "type": "boolean",
                        "description": "HN search is typo-tolerant (e.g. \"shopify\" can return \"spotify\"). When on, only items where the keyword appears as a whole word in the title/text are returned — avoids false positives for brand monitoring. Turn off for broader/fuzzy discovery.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```