# Hacker News Keyword Monitor (`navy_currant/deal-radar`) Actor

Monitor Hacker News for any keyword on a schedule. Returns new stories and comments mentioning your term, deduplicated so you only see fresh matches. Perfect for brand, competitor, and topic tracking.

- **URL**: https://apify.com/navy\_currant/deal-radar.md
- **Developed by:** [Ishaan](https://apify.com/navy_currant) (community)
- **Categories:** Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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 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

## Hacker News Keyword Monitor 🔔

**Track any keyword on Hacker News, automatically.** This actor watches Hacker News for the
terms you care about and returns **new stories and comments** that mention them — deduplicated
across runs, so you only ever see fresh results, never the same post twice.

Set it on a schedule and it becomes a hands-off **alert feed**: brand mentions, competitor
activity, your product or company name, a technology, a person, or any topic — delivered to a
dataset you can export, pipe into a webhook, or connect to Slack, Zapier, and Make.

---

### 💡 What you can use it for

- **Brand & reputation monitoring** — know the moment your company or product hits the HN front page or comments.
- **Competitor tracking** — get alerted when a rival launches, raises, or gets discussed.
- **Lead & community signals** — catch "Ask HN" and "Show HN" posts relevant to your niche.
- **Topic & tech tracking** — follow a framework, tool, or trend without refreshing HN all day.
- **PR & launch monitoring** — watch the discussion around your own Show HN in real time.

### ✨ Features

- 🔎 Searches **both stories and comments** via the official Hacker News (Algolia) search API — fast and always current.
- 🧠 **Deduplicated** — remembers what it has already returned, so scheduled runs surface only new mentions.
- ⏱️ **Schedule-ready** — run it every few minutes or hours for a continuous alert stream.
- 🎚️ **Filters** — minimum points, stories-only, and a per-run item cap.
- 📤 **Export anywhere** — JSON, CSV, Excel, or push to webhooks / Slack / Zapier / Make.

### 🧾 Input

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | The keyword or phrase to watch for. |
| `searchComments` | boolean | Also match comments, not just stories. |
| `minPoints` | integer | Only return stories at/above this many points (optional). |
| `onlyNewSinceLastRun` | boolean | Suppress items already returned in earlier runs. |
| `maxItems` | integer | Cap on matches per run. |

```json
{
  "query": "your product name",
  "searchComments": true,
  "minPoints": null,
  "onlyNewSinceLastRun": true,
  "maxItems": 50
}
````

### 📦 Output

Each match is one dataset item:

```json
{
  "type": "story",
  "title": "Show HN: My new tool",
  "text": null,
  "author": "pg",
  "points": 142,
  "numComments": 37,
  "url": "https://example.com",
  "hnUrl": "https://news.ycombinator.com/item?id=12345678",
  "createdAt": "2026-07-11T03:20:24Z",
  "foundAt": "2026-07-11T07:19:06Z"
}
```

### ⏰ Recommended setup

1. Set `query` to your keyword and turn on `onlyNewSinceLastRun`.
2. Create a **Schedule** (e.g. every hour).
3. Connect an **integration** (Slack, webhook, email, Zapier) to be notified on new matches.

That's it — a fully automated Hacker News alert for your keyword.

### ❓ FAQ

**How often should I run it?** Anywhere from every few minutes to a few times a day. Dedup means
you'll never get repeats regardless of frequency.

**Does it cover comments?** Yes — set `searchComments` to true (default).

**Will I get the same post twice?** No. With `onlyNewSinceLastRun` on, each run returns only
items it hasn't returned before.

**What does it cost?** Pay-per-event: a small charge per run plus per new result. You pay only
for runs you trigger and results you receive.

***

*Keywords: Hacker News scraper, HN monitor, keyword alerts, brand monitoring, competitor
tracking, mention tracking, news monitoring, Hacker News API, HN search, topic alerts.*

# Actor input Schema

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

What to watch for on Hacker News (e.g. a product name, competitor, or topic).

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

Also match Hacker News comments, not just stories.

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

Only return stories at or above this many points. Leave empty for no filter.

## `onlyNewSinceLastRun` (type: `boolean`):

Suppress items already seen in earlier runs, so scheduled runs surface only fresh matches.

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

Safety cap on matches fetched per run.

## Actor input object example

```json
{
  "query": "apify",
  "searchComments": true,
  "onlyNewSinceLastRun": true,
  "maxItems": 50
}
```

# 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 = {
    "query": "apify"
};

// Run the Actor and wait for it to finish
const run = await client.actor("navy_currant/deal-radar").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 = { "query": "apify" }

# Run the Actor and wait for it to finish
run = client.actor("navy_currant/deal-radar").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 '{
  "query": "apify"
}' |
apify call navy_currant/deal-radar --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hacker News Keyword Monitor",
        "description": "Monitor Hacker News for any keyword on a schedule. Returns new stories and comments mentioning your term, deduplicated so you only see fresh matches. Perfect for brand, competitor, and topic tracking.",
        "version": "0.1",
        "x-build-id": "vQfuFwDtVxQew5LHI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/navy_currant~deal-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-navy_currant-deal-radar",
                "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/navy_currant~deal-radar/runs": {
            "post": {
                "operationId": "runs-sync-navy_currant-deal-radar",
                "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/navy_currant~deal-radar/run-sync": {
            "post": {
                "operationId": "run-sync-navy_currant-deal-radar",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Keyword / phrase",
                        "type": "string",
                        "description": "What to watch for on Hacker News (e.g. a product name, competitor, or topic)."
                    },
                    "searchComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Also match Hacker News comments, not just stories.",
                        "default": true
                    },
                    "minPoints": {
                        "title": "Minimum points",
                        "type": "integer",
                        "description": "Only return stories at or above this many points. Leave empty for no filter."
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "Suppress items already seen in earlier runs, so scheduled runs surface only fresh matches.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items per run",
                        "maximum": 200,
                        "type": "integer",
                        "description": "Safety cap on matches fetched per run.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
