Product Hunt Scraper — New Launch Alerts
Pricing
from $7.00 / 1,000 new launches
Product Hunt Scraper — New Launch Alerts
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.
Pricing
from $7.00 / 1,000 new launches
Rating
0.0
(0)
Developer
Magnova
Maintained by CommunityActor stats
0
Bookmarked
3
Total users
2
Monthly active users
9 hours ago
Last modified
Categories
Features
Share
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
- 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. - 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.
- 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).
- 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 (
aimatches "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 reportsstoppedByMaxChargewhen 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.actorAuthorization: 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
launchIds 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.