# Product Hunt Scraper — New Launch Alerts (`magnova/product-hunt-launches-monitor`) Actor

Scrape Product Hunt launches from the official feed — product name, tagline, Product Hunt page, product link, launch time, maker name. Monitoring mode delivers only launches new since your last run, optionally by keyword. $0.01 per new launch, no start fee, runs with no new launches are free.

- **URL**: https://apify.com/magnova/product-hunt-launches-monitor.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Business, Automation, Marketing
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 new launches

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Product Hunt Scraper — New Launch Alerts

**Scrape Product Hunt's official feed and get every launch in it as clean structured data — product name, tagline, Product Hunt page, product link, launch time and maker name.**

Product Hunt launches dozens of products a day, and its homepage forgets them just as fast. This Actor scrapes Product Hunt's official Atom feed for you: every run delivers the launches currently in the feed as structured records. Attach a monitor store and schedule it, and **monitoring mode** delivers **only the launches no earlier run has seen** — a quiet new-product alert feed for your niche, your competitors, or the whole firehose, with no re-reading the homepage and no paying for the same launches twice.

Monitoring mode is the difference from a snapshot dump: it remembers what it has already delivered and sends you only the delta.

### What it does

- **Scrapes all of Product Hunt.** The feed carries every public launch, so one Actor covers the entire platform — no per-product or per-category setup.
- **Complete launch records.** Product name, tagline, Product Hunt page, the product link with an honest flag saying whether it is the product's own website URL or Product Hunt's redirect link to it, the launch timestamp in UTC, and the maker's public display name.
- **Monitoring mode (delta-only delivery).** With a monitor state store attached, each run delivers only genuinely new launches. A slot with no new launches produces an empty result and costs nothing.
- **Optional keyword filtering.** Give keywords and only launches whose name or tagline contains one of them (a case-insensitive substring match, done by the Actor against the feed text) are delivered. Leave keywords empty and you get the full firehose.
- **Loud failure, never silent emptiness.** If the feed cannot be read, the run writes an ERROR record and the SUMMARY says `feedError: true` — and the monitor state is **not** advanced, so the next run catches up instead of silently losing launches. A broken feed never looks like a quiet day.

### How monitoring works

1. **First run.** Without a store, the run delivers the feed's current launches as a *baseline batch* (charged normally), so you start with data, not an empty feed. Prefer to start silently? Turn on **Start monitoring silently** (`monitorOnlyNew`) and the first run only remembers the current launches; delivery starts with the next new launch.
2. **Attach a store.** Pick any of your Apify key-value stores in the **Monitor state store** input. The Actor keeps one small record in it: the launch IDs it has already seen. It remembers *every* launch the feed showed it — including launches your keywords filtered out — so changing keywords later does not re-deliver old launches.
3. **Schedule it — at least daily.** The feed is a rolling window of roughly 50 entries: Product Hunt surfaces the most recently active launches there, and every launch enters the feed when it goes live — but entries also fall out of the window as activity moves on. (In staging, the window's launch dates ranged from a few hours old to several weeks old: it is an activity window, not a strict "today" list.) **A monitor that runs less often than daily can permanently miss launches that entered and left the window between runs.** Daily is the safe cadence; more often is harmless (repeat checks are free — you only pay for new launches).
4. **Filter if you want.** Keywords are matched as case-insensitive substrings of the product name and tagline — exactly that, nothing smarter. Short keywords match inside other words (`ai` matches "email" and "said"), so prefer distinctive words or phrases: `"artificial intelligence"`, `"video editor"`, `"for developers"`.

### Inputs

| Input | Type | Description |
| --- | --- | --- |
| `keywords` | array of strings (optional) | Keyword filter. Empty/absent = every new launch. A launch is delivered when one keyword appears as a case-insensitive substring of its name or tagline. Up to 20 keywords. |
| `monitorOnlyNew` | boolean (default false) | When true, the first run silently remembers the current feed instead of delivering a baseline batch. Only launches that appear afterwards are ever delivered. |
| `monitorStore` | key-value store (optional) | The store that remembers seen launches across runs — this is what makes only-new delivery work. Without it, every run is a full baseline run. |
| `sinceDate` | string, ISO 8601 date or datetime (optional) | Stateless cursor: deliver only launches published on or after this moment. For workflow tools that hold state themselves — see "Stateless cursor" below. Empty = no cursor. |

### Stateless cursor (no store needed)

If your workflow tool (Make, Zapier, your own scheduler) already tracks where it got to, you do not need the monitor store at all: pass `sinceDate` — an ISO 8601 date (`2026-11-01`, read as the start of that day, UTC) or datetime (`2026-11-01T12:00:00Z`) — and the run delivers only launches whose `publishedAt` is on or after it. Your workflow stores the cursor; the Actor stays stateless.

- A launch published at exactly the cursor moment is included.
- Cursor-filtered launches are never charged, and they stay **unseen** in the monitor store, so a later run with an earlier or no cursor can still deliver them. The SUMMARY reports how many were filtered out (`cursorFilteredOut`) whenever a cursor is set.
- The cursor only ever narrows the current feed window — it cannot recover launches that have already fallen out of the rolling ~50-entry feed window, so the run-at-least-daily guidance above still applies.
  | `maxTotalChargeUsd` | number (optional) | Hard stop for the run's charges; the SUMMARY reports `stoppedByMaxCharge` when it fires. Undelivered new launches stay unseen, so the next run delivers them. |

### Use it as an API (Server Actor)

This actor also runs as a **server**: send one HTTP request and get the launches back in the response — no run to start, no dataset to poll.

```
POST https://magnova--product-hunt-launches-monitor.apify.actor
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json

{"keywords": ["ai"], "sinceDate": "2026-11-01"}
```

The body takes the same fields as the normal input. The response is `{"records": [...], "summary": {...}}`. Server mode is a snapshot lookup — the monitor state store stays a scheduled/batch-run feature — and one request returns at most ~100 launches. You are charged the same $0.01 per delivered launch as a normal run (tiered by your Apify plan), billed to your own Apify account; error rows are never charged.

### Outputs

Every run writes up to three kinds of records to the dataset:

**`NEW_LAUNCH` records — one per new launch (the charged records):**

| Field | Meaning |
| --- | --- |
| `launchId` | The launch's stable Product Hunt Post ID |
| `name` | The product's name, exactly as published in the feed |
| `tagline` | The product's tagline, from the feed entry's description text (null when the entry carries none) |
| `productHuntUrl` | The launch's page on Product Hunt |
| `productLink` | The product's own website URL when Product Hunt's redirect resolved; otherwise Product Hunt's own redirect link (`producthunt.com/r/p/...`), which leads to the same product site |
| `productLinkResolved` | `true` when `productLink` is the product's own website URL; `false` when it is Product Hunt's redirect link because the redirect could not be resolved from the run's network |
| `publishedAt` | The launch timestamp (UTC, ISO 8601) |
| `makerName` | The maker's public display name, exactly as the feed publishes it (the only maker field the feed carries) |
| `matchedKeywords` | Keyword-filtered runs only: which of your keywords matched this launch |

**`ERROR` records** — written when the feed itself could not be fetched or parsed in this run (never charged), with the reason. Monitor state is not advanced on a feed error; the next run catches up.

**One `SUMMARY` record** at the end of every run (never charged): how many launches the feed held, how many matched your keywords, how many were delivered as new, duplicates skipped, filtered out, silently seeded, how many product links resolved to the product's own site, whether a state store was used, whether the feed errored, and whether the run stopped at your maximum charge or the platform timeout.

### Pricing

**$0.01 per new launch delivered.** No start fee, no per-run fee, no charge for checking. Volume tiers apply automatically: SILVER pays $0.0085 per new launch, GOLD and above $0.007.

- Already-seen launches: **free** (skipped as duplicates).
- Launches your keywords filtered out: **free**.
- Silently seeded launches (`monitorOnlyNew`): **free**.
- ERROR records and the SUMMARY: **free**.
- A run that finds no new launches costs **$0**.

Compare that with snapshot scrapers, which charge for the entire current homepage on every run — a daily snapshot habit costs many times more per month than monitoring, where a typical niche filter delivers a handful of genuinely new launches a day.

### Use cases

- **Niche launch alerts.** Track every new AI tool, dev tool, or SaaS product in your space the day it launches — name, tagline, link and maker — without opening Product Hunt.
- **Competitive and market research.** Build a clean, deduplicated stream of launches in a category for trend tracking, prospecting, or content research; stable `launchId`s make downstream joins and de-duping trivial.
- **Investor and analyst scanning.** A daily only-new feed of everything launched, filterable by keyword, ready to pipe into a spreadsheet, CRM, Slack or an agent workflow.
- **Maker watching.** Follow what rival makers ship: their next launch lands in your dataset the day it goes live.

### For AI agents and MCP

This Actor is designed to be driven by AI agents via the Apify MCP server. Inputs are minimal and self-describing: every field is optional, an empty input is a valid full-firehose baseline run, and the keyword semantics are stated exactly (case-insensitive substring over name and tagline — no hidden topic model). Outputs are one flat record per new launch with a stable ID (`launchId`) suitable for deduplication, alerting and downstream joins, plus a machine-readable SUMMARY record with counts and stop reasons (`stoppedByMaxCharge`, `feedError`). A typical agent workflow: run once with a `monitorStore` and `monitorOnlyNew: true` to seed, then schedule daily runs against the same store and forward only runs whose SUMMARY reports `deliveredNew > 0`.

### Product Hunt API

Product Hunt's official API requires a personal account token, so tools built on it cannot run for you keylessly. This Actor instead reads Product Hunt's **official Atom feed** — the syndication feed Product Hunt itself publishes at `producthunt.com/feed` so that feed readers and tools can follow new launches. It is the same launch data the homepage shows (name, tagline, links, launch time, maker display name), in a stable machine-readable form, with no account and no key. The feed does not carry votes, daily rank, topics or comment counts, so this Actor does not emit them — every field shipped is a field the feed actually contains.

### Legal and data

Product Hunt publishes its Atom feed openly so that anyone — readers, aggregators, tools — can syndicate and follow new launches. This Actor reads only that official public feed. It never fetches the Product Hunt website itself, uses no login or account, bypasses no access control, and sets no cookies. It collects **only what the feed publishes**: product names, taglines, links, launch times, and makers' public display names exactly as they appear in the feed. Maker profile URLs, contact details and all other personal data are neither present in the feed nor collected. Launch data remains Product Hunt's and the makers'; respect Product Hunt's terms and your local law when reusing it.

### FAQ

**Why did my run deliver launches from several days (or weeks) ago?** Because the baseline is the feed's current window, and that window is an activity window, not a strict "today" list: it holds roughly 50 recently active launches, whose launch dates in staging ranged from a few hours to several weeks old. On a first (baseline) run you receive the whole window. From the second run on, you receive only launches that are new since the previous run.

**Why must I run it at least daily?** The feed is a rolling window: new launches push older ones out. If more launches happen between two of your runs than the window holds, the overflow leaves the feed unseen and cannot be recovered — no tool can deliver a launch the feed no longer carries. Daily runs keep you safely inside the window.

**A launch is missing its tagline / its product link goes through Product Hunt. Why?** Both come straight from the feed. A launch whose feed entry carries no tagline text ships `tagline: null` rather than an invented line. For the product link, the Actor follows Product Hunt's redirect to the product's own site whenever the network allows it (`productLinkResolved: true`); when the redirect cannot be resolved from a run's network, you get Product Hunt's own redirect link instead — it leads to the same product site — with `productLinkResolved: false`, so nothing is ever disguised.

**Can I filter by category or topic?** No — and be wary of feed-based tools that claim to: the feed carries no topic or category data. The honest filter is the keyword match described above (case-insensitive substring over name and tagline). If you need topic classification, apply it downstream to the delivered taglines.

**Where are the vote counts and daily ranks?** The feed does not publish them, so this Actor does not invent or scrape them. Every field in the output is a field the feed actually contains.

**How is this different from a Product Hunt scraper?** A scraper returns the current homepage per run (and charges for all of it, every run). This monitor returns only the launches that are new since your last run — which is what alerting, tracking and research workflows actually consume — and charges only for those.

**What counts as "new"?** A launch ID the monitor has never seen in the feed (delivered, seeded, or filtered out — all are remembered when a monitor store is attached). Without a store, every run is a baseline and delivers the whole current window.

# Actor input Schema

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

Optional keyword filter. Leave empty to receive EVERY new launch (the full firehose). When you give keywords, a launch is delivered only if one of your keywords appears — as a case-insensitive substring — in the product's name or its tagline. The matching is done by this Actor against the feed text, exactly as described: it is a plain substring match, not a topic or category filter (Product Hunt's feed carries no topics), so a short keyword like "ai" also matches inside words such as "email" or "said" — prefer distinctive words or phrases ("artificial intelligence", "video editor", "for developers"). Up to 20 keywords. Applies to NEW launches only: the monitor remembers every launch it has seen, including ones your keywords filtered out, so widening the list later does not re-deliver old launches.

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the feed's current launches as a baseline batch (charged), later runs deliver only new ones. On: the first run silently remembers the current launches without delivering or charging anything, and only launches that appear afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `monitorStore` (type: `string`):

A key-value store this Actor may read and write to remember which launches it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the feed's current launches as a NEW baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. Note: the Actor remembers every launch the feed showed it (including launches your keywords filtered out), so changing keywords later does not re-deliver old launches.

## `maxTotalChargeUsd` (type: `number`):

Optional hard stop for this run's charges: delivery stops as soon as the charged launches reach this amount (checked conservatively at the highest per-launch price, so the run may stop slightly early on discounted tiers), and the SUMMARY record reports stoppedByMaxCharge. Undelivered new launches stay unseen, so the next run delivers them. Leave empty for no cap. The run-level maximum charge in the run options is also honoured exactly.

## `sinceDate` (type: `string`):

Optional stateless cursor for workflow tools (Make, Zapier, your own scheduler) that hold state themselves: when set, only launches published on or after this ISO 8601 date or datetime are delivered — for example "2026-11-01" (the start of that day, UTC) or "2026-11-01T12:00:00Z". Leave it empty for the normal behavior. Filtered-out launches are never charged and stay unseen in the monitor store, so a later run with an earlier or no cursor can still deliver them. The cursor only narrows the current feed window; it cannot recover launches that have already fallen out of the rolling feed window.

## Actor input object example

```json
{
  "keywords": [
    "artificial intelligence",
    "video editor"
  ],
  "monitorOnlyNew": false,
  "maxTotalChargeUsd": 1,
  "sinceDate": "2026-11-01"
}
```

# 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 = {
    "monitorOnlyNew": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/product-hunt-launches-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 = { "monitorOnlyNew": False }

# Run the Actor and wait for it to finish
run = client.actor("magnova/product-hunt-launches-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "monitorOnlyNew": false
}' |
apify call magnova/product-hunt-launches-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magnova/product-hunt-launches-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/uAJcr4yZUPB6AmXbv/builds/LmDLQYVaDAd5cXm5Z/openapi.json
