Product Hunt Launches Scraper

Export the current public Product Hunt launches feed as structured JSON, CSV, Excel, or API-ready dataset records.

The Actor reads Product Hunt's public Atom feed and returns each launch's title, product URL, content, author, published time, and updated time. Optional keyword and recency filters make the same feed useful for one-time research or scheduled daily product monitoring.

What does Product Hunt Launches Scraper do?

Product Hunt Launches Scraper turns the public feed at https://www.producthunt.com/feed into normalized dataset rows.

It can:

• export the current launch feed without a Product Hunt API key or login;
• filter launches by words found in the title, content, or author;
• select records updated or published within a rolling number of hours;
• keep both normalized text and the original feed HTML;
• preserve Product Hunt's stable entry and post identifiers;
• run on an Apify schedule for recurring monitoring;
• feed results into webhooks, datasets, spreadsheets, or another Actor.

This is a focused feed exporter. It does not scrape votes, comments, topics, maker profiles, historical rankings, or arbitrary product-detail pages.

Who is it for?

Product and market researchers can collect a repeatable daily snapshot of launch names, summaries, links, and timestamps.

Competitive-intelligence teams can filter the feed for categories, technologies, or competitor terms and compare scheduled datasets downstream.

Developers can use the Actor as a credential-free Product Hunt API alternative for the fields exposed by the public Atom feed.

No-code operators can schedule a run and connect its dataset to Zapier, Make, Google Sheets, Slack, or a webhook.

Newsletters and content teams can collect current launches before editorial review. Always verify source content before republishing it.

Why use this Actor?

• No Product Hunt credentials: the source is the public Atom feed.
• Direct structured route: no browser, residential proxy, or page rendering is needed.
• Typed output: dates are normalized to ISO 8601 UTC and identifiers have stable fields.
• Monitoring controls: rolling updated/published windows work naturally with schedules.
• Useful content choices: retain source HTML or request plain text only.
• Fail-closed behavior: malformed input and invalid upstream responses fail clearly rather than returning misleading rows.

What Product Hunt data is extracted?

Field	Type	Meaning
entryId	string	Stable Product Hunt Atom entry ID
productId	string or null	Numeric post ID parsed from the entry ID
title	string	Product or launch title
url	string	Product Hunt product page URL
content	string or null	Normalized plain-text summary and feed links
contentHtml	string or null	Original HTML summary when enabled
author	string or null	Author name exposed by the feed
publishedAt	ISO date	Product Hunt published timestamp in UTC
updatedAt	ISO date	Feed update timestamp in UTC
feedPosition	integer	One-based position in the fetched feed
sourceFeedUrl	URL	Canonical feed URL used by the run
scrapedAt	ISO date	Time the Actor processed the feed

Nullable fields reflect the public source: Product Hunt may omit optional values from an entry.

Getting started

1. Open Product Hunt Launches Scraper in Apify Console.
2. Leave the prefilled maxItems and includeContentHtml settings for a first run.
3. Optionally add keywords or a rolling time window.
4. Click Start.
5. Open the Dataset tab when the run succeeds.
6. Export records as JSON, CSV, Excel, XML, or RSS, or consume the dataset API URL.
7. For recurring monitoring, create an Apify schedule and use updatedWithinHours to match the schedule interval.

A first run needs no proxy configuration, login, token, Product Hunt account, or custom feed URL.

Input parameters

maxItems

Maximum matching records to save from the current feed.

• Default: 20
• Minimum: 1
• Maximum: 100

The public feed currently has a bounded set of entries. Asking for 100 does not invent historical data; the Actor stops when the feed is exhausted.

keywords

Optional list of up to 20 case-insensitive terms. A launch matches when any term occurs in its title, content, or author name.

Use an empty list to export the feed without keyword filtering.

updatedWithinHours

Optional rolling window from 1 to 8760 hours. This tests the Atom entry's updated timestamp and is the recommended filter for scheduled change monitoring.

publishedWithinHours

Optional rolling window from 1 to 8760 hours. This tests the source published timestamp. Product Hunt may publish a product before the entry is updated in the current daily feed, so this filter can return fewer records than updatedWithinHours.

includeContentHtml

When true, contentHtml retains the original Atom HTML. When false, the Actor still emits normalized content but sets contentHtml to null.

Input examples

Export the current feed:

{
  "maxItems": 20,
  "includeContentHtml": true
}

Find AI-related launches:

{
  "maxItems": 10,
  "keywords": ["AI", "artificial intelligence"],
  "includeContentHtml": false
}

Monitor entries updated during the last day:

{
  "maxItems": 100,
  "updatedWithinHours": 24,
  "includeContentHtml": false
}

Output example

A current feed record has this shape:

{
  "entryId": "tag:www.producthunt.com,2005:Post/1227752",
  "productId": "1227752",
  "title": "Enter Pro",
  "url": "https://www.producthunt.com/products/enter-pro",
  "content": "The AI-native platform to build and scale your apps Discussion | Link",
  "contentHtml": null,
  "author": "Rohan Chaubey",
  "publishedAt": "2026-08-20T14:14:52.000Z",
  "updatedAt": "2026-08-27T14:41:02.000Z",
  "feedPosition": 1,
  "sourceFeedUrl": "https://www.producthunt.com/feed",
  "scrapedAt": "2026-08-27T14:41:45.481Z"
}

The default dataset is the primary integration output. Filtering happens before charging and saving, so rejected and duplicate-free nonmatching entries do not become dataset items.

How much does it cost to export Product Hunt launches?

The Actor uses pay-per-event pricing:

• one start event per run;
• one item event for each saved launch record;
• no charge for feed entries rejected by your filters.

At the BRONZE rate, the start event is $0.005 and each saved item is $0.012936. Tier prices decrease for higher Apify account tiers.

Approximate BRONZE examples:

Saved launches	BRONZE calculation
1	$0.005 start + 1 × $0.012936 per item
10	$0.005 start + 10 × $0.012936 per item
50	$0.005 start + 50 × $0.012936 per item

The actual run charge is shown in Apify Console. The final number depends on saved items and the pricing tier assigned to your account, not on how many feed entries are inspected.

Daily launch monitoring workflow

1. Create a Task with updatedWithinHours set to your schedule interval plus a small overlap.
2. Set maxItems high enough to accept all matching current-feed entries.
3. Run the Task daily or several times per day with an Apify schedule.
4. Send completed-run data to a webhook or integration.
5. Deduplicate downstream by stable entryId and compare updatedAt to detect changes.
6. Keep the newest record for an ID when monitoring across multiple datasets.

The Actor does not maintain a private historical database or send alerts itself. Apify schedules, dataset retention, webhooks, and your downstream workflow provide those capabilities.

API usage

Replace YOUR_APIFY_TOKEN with an Apify API token.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~product-hunt-launch-feed-scraper/runs?token=YOUR_APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":20,"updatedWithinHours":24,"includeContentHtml":false}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/product-hunt-launch-feed-scraper').call({
  maxItems: 20,
  updatedWithinHours: 24,
  includeContentHtml: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/product-hunt-launch-feed-scraper").call(
    run_input={
        "maxItems": 20,
        "updatedWithinHours": 24,
        "includeContentHtml": False,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

Use with Apify MCP

Add this Actor to Claude Code:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/product-hunt-launch-feed-scraper"

Claude Desktop, Cursor, and VS Code use this MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/product-hunt-launch-feed-scraper"
    }
  }
}

Example prompts:

• “Run Product Hunt Launches Scraper and return the first 20 current launches.”
• “Find launch feed records mentioning AI and summarize their source URLs.”
• “Export Product Hunt records updated during the last 24 hours.”

Integrations

Use the default dataset with:

• Apify webhooks for completed-run delivery;
• Google Sheets for a lightweight daily launch log;
• Make or Zapier for no-code routing;
• Slack or email steps after downstream filtering;
• BigQuery, Snowflake, or a database for historical comparison;
• another Actor for enrichment using the emitted Product Hunt URLs.

Stable entryId, productId, url, and timestamps make dataset joins and deduplication straightforward.

Limits and freshness

• The Actor exports only entries currently exposed by Product Hunt's public Atom feed.
• It does not provide full history or arbitrary date pagination.
• Feed order and contents are controlled by Product Hunt and can change.
• publishedAt and updatedAt have different meanings and can be far apart.
• Keyword matching is a case-insensitive substring match, not semantic classification.
• Content is source-provided and can contain links or markup.
• The Actor makes one bounded feed request per attempt and retries only transient network, 429, and 5xx failures.
• A successful no-result run is possible when filters match no current entry.

Troubleshooting

The dataset is empty

Remove keyword and time filters, then run the prefilled input. A narrow publishedWithinHours filter often excludes entries that were published earlier but updated today.

The run failed with an upstream HTTP or content-type error

Product Hunt may be temporarily unavailable or may have changed the public feed. Retry later after checking the run log. Deterministic invalid responses are not silently treated as empty datasets.

I requested 100 items but received fewer

maxItems is a ceiling. The public feed may contain fewer records, and filters can reduce the result further.

Where are votes, comments, topics, and maker profiles?

Those fields are not in this focused public-feed contract. This Actor intentionally avoids claiming product-detail or authenticated API data.

Responsible use and legality

This Actor accesses a public Product Hunt feed without bypassing login or access controls.

You are responsible for:

• following Product Hunt's applicable terms and policies;
• respecting copyright, database rights, and attribution requirements;
• using personal names lawfully and only for a legitimate purpose;
• avoiding spam, harassment, profiling, or automated republishing without review;
• securing exported datasets and complying with applicable privacy law;
• checking source content before making decisions or publishing summaries.

Public availability does not remove your legal or contractual responsibilities.

Related Actors

This Actor is intentionally standalone within the Automation Lab portfolio: no currently active Automation Lab Actor provides a directly complementary Product Hunt feed workflow that can be recommended honestly.

For enrichment, pass emitted url values into your own approved downstream workflow or use Apify integrations rather than assuming this Actor includes product-page details.

FAQ

Does it require a Product Hunt API token?

No. It reads the public Atom feed.

Does it require an Apify proxy?

No. The current implementation uses direct HTTP and has no user-triggerable proxy fallback.

Can it scrape a specific historical date?

No. It filters the records currently present in the feed; it does not paginate a historical archive.

Can I monitor only one topic?

Use keywords for terms found in the launch title, content, or author. This is text filtering, not Product Hunt topic metadata.

Are unchanged entries charged?

Every record saved by a run emits one item charge.

To limit repeated records, use a rolling update window and deduplicate across runs by entryId and updatedAt.

Can I disable source HTML?

Yes. Set includeContentHtml to false; normalized plain text remains available in content.

Will an empty match be treated as a failure?

No. Valid filters that match no current entries produce a successful run with an empty dataset. Invalid input or an invalid upstream response fails clearly.