Product Hunt Scraper

Export recent Product Hunt launches into a clean Apify dataset with product names, taglines, launch dates, Product Hunt URLs, outbound links, and cache-aware freshness controls.

Use this actor to monitor new products, collect launch inspiration, build lead lists, compare competitors, and keep a lightweight record of Product Hunt activity without paying for heavy browser automation.

What does Product Hunt Scraper do?

Product Hunt Scraper collects product rows from Product Hunt's current launch feed and saves them as structured dataset items.

Each row includes the product name, tagline, Product Hunt URL, launch timestamp, launch date, optional outbound redirect URL, cache status, and scrape timestamp.

Who is it for?

• 🧑‍💼 Founders tracking adjacent launches.
• 📈 Growth teams building daily launch dashboards.
• 🕵️ Competitive intelligence analysts watching new tools.
• 📰 Newsletter writers collecting fresh startup ideas.
• 🧪 Product researchers validating category momentum.
• 🤖 Automation builders feeding Product Hunt rows into CRMs, Sheets, Airtable, or Slack.

Why use this actor?

Product Hunt pages can be expensive to crawl with browsers. This actor is intentionally lightweight. It focuses on launch rows that are available through a low-cost feed path and avoids third-party email enrichment by default.

That means faster runs, lower compute cost, and predictable pay-per-event billing.

Product Hunt launch fields you can export

Field	Description
id	Stable ID derived from the Product Hunt product URL.
title	Product name.
tagline	Short product tagline or description.
productUrl	Product Hunt product page URL.
discussionUrl	Product Hunt discussion URL.
outboundUrl	Product Hunt outbound redirect URL when present.
launchedAt	Launch/update timestamp from Product Hunt.
launchDate	Date portion of the launch timestamp.
source	Source feed URL.
cacheStatus	fresh or cached.
scrapedAt	Time this actor saved the row.

How much does it cost to scrape Product Hunt launches?

The actor uses pay-per-event pricing.

• Actor start: small one-time run charge.
• Fresh product row: charged when a row is read from Product Hunt during the run.
• Cached product row: charged at a lower rate when a still-fresh cache entry is reused.

The default cache TTL is 12 hours. Set forceFresh to true when freshness matters more than cost. Use fresh runs for time-sensitive launch monitoring; use cached rows when cost matters more than freshness.

Cost-saving cache behavior

The actor stores product rows in a named key-value cache keyed by Product Hunt URL.

If another run asks for the same row while the cache entry is still inside cacheTtlHours, the actor returns the cached row and marks it as cacheStatus: "cached".

This is designed to reduce repeat-run cost for dashboards and scheduled automations.

Freshness guardrails

You stay in control of stale data risk.

• Set forceFresh to ignore cache.
• Set cacheTtlHours to 0 to disable cache reads and writes.
• Lower cacheTtlHours for fast-moving workflows.
• Check cacheStatus and scrapedAt in every output row.

Input options

Input	Type	Default	Description
maxItems	integer	20	Maximum number of products to save, up to 50 recent launches from Product Hunt's current public feed.
launchDate	string	empty	Optional YYYY-MM-DD date filter.
startUrls	array	empty	Optional Product Hunt URLs to keep if present in the current feed.
includeRedirectUrl	boolean	true	Include Product Hunt outbound redirect URLs.
cacheTtlHours	integer	12	Cache lifetime from 0 to 168 hours.
forceFresh	boolean	false	Ignore cache for this run.

Example input

{
  "maxItems": 20,
  "cacheTtlHours": 12,
  "forceFresh": false,
  "includeRedirectUrl": true
}

Example input for a fresh run

{
  "maxItems": 50,
  "forceFresh": true,
  "cacheTtlHours": 0,
  "includeRedirectUrl": true
}

Example input with URL filter

{
  "startUrls": [
    { "url": "https://www.producthunt.com/products/example-product" }
  ],
  "maxItems": 10
}

Output example

{
  "id": "www.producthunt.com_products_crewdle",
  "title": "Crewdle AI",
  "tagline": "Use every business AI tool without every subscription",
  "productUrl": "https://www.producthunt.com/products/crewdle",
  "discussionUrl": "https://www.producthunt.com/products/crewdle",
  "outboundUrl": "https://www.producthunt.com/r/p/1178240?app_id=339",
  "launchedAt": "2026-06-24T13:12:05-07:00",
  "launchDate": "2026-06-24",
  "source": "https://www.producthunt.com/feed",
  "cacheStatus": "fresh",
  "scrapedAt": "2026-06-24T20:00:00.000Z"
}

How to run

1. Open the actor on Apify.
2. Keep the prefilled input for a quick test.
3. Choose your maximum product count, up to 50 recent launches.
4. Decide whether cached rows are acceptable.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, XML, or RSS.

Tips for best results

• Use a small maxItems for quick checks.
• Use maxItems: 50 when you want the full currently available public feed; older archive-scale exports are intentionally out of scope for this low-cost mode.
• Use scheduled runs for daily launch monitoring.
• Keep caching on for dashboards that refresh frequently.
• Use forceFresh before publishing a report.
• Leave launchDate empty unless you specifically need to filter the current feed by date.

Limitations

This actor focuses on low-cost launch rows. It does not enrich third-party websites for emails, founders, or social profiles.

Older Product Hunt archive pages may require heavier crawling. Product Hunt's current public feed currently exposes up to 50 recent launches; if it does not contain a requested date or URL, the actor may return no rows for that filter.

Integrations

Send Product Hunt rows to:

• Google Sheets for a daily launch tracker.
• Airtable for startup research databases.
• Slack for launch alerts.
• Notion for content planning.
• CRMs for founder outreach workflows.
• BI tools through Apify dataset exports.

API usage with Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/product-hunt-scraper').call({
  maxItems: 20,
  cacheTtlHours: 12,
});
console.log(run.defaultDatasetId);

API usage with Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/product-hunt-scraper').call(run_input={
    'maxItems': 20,
    'cacheTtlHours': 12,
})
print(run['defaultDatasetId'])

API usage with cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~product-hunt-scraper/runs?token=<APIFY_TOKEN>' \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":20,"cacheTtlHours":12}'

MCP usage

Use this actor through Apify MCP from Claude Desktop or Claude Code.

MCP URL pattern:

https://mcp.apify.com/?tools=fetch_cat/product-hunt-scraper

Claude Code setup:

$claude mcp add apify-product-hunt --url "https://mcp.apify.com/?tools=fetch_cat/product-hunt-scraper"

Claude Desktop JSON config example:

{
  "mcpServers": {
    "apify-product-hunt": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/product-hunt-scraper"
    }
  }
}

Example prompts:

• "Run Product Hunt Scraper for 25 products and summarize the most interesting AI launches."
• "Export today's Product Hunt rows and draft a founder outreach shortlist."
• "Compare cached and fresh Product Hunt rows from my latest run."

Scheduling ideas

Run the actor every morning to collect launches.

Run it every few hours during a launch day if you are monitoring competitors.

Turn on cache for frequent schedules to reduce repeated row cost.

Troubleshooting: no results

If a run returns no rows, remove launchDate and startUrls and run the prefilled input.

The current feed may not include older dates or a specific product URL.

Troubleshooting: stale rows

If a row is marked cached, lower cacheTtlHours or set forceFresh to true.

Every row includes scrapedAt so you can audit freshness.

FAQ

Can I scrape older Product Hunt launch dates?

The actor can filter by launchDate when that date is present in the current Product Hunt feed. Older archive pages may not be available through this low-cost mode.

How do I avoid stale cached rows?

Set forceFresh to true or set cacheTtlHours to 0.

Does this actor collect emails?

No. Email enrichment is intentionally excluded from the default Product Hunt launch workflow to keep runs cheaper and simpler.

Legality

Use Product Hunt Scraper responsibly and follow Product Hunt terms, Apify terms, and applicable laws. The actor exports publicly available launch-feed fields and does not bypass login-only data.

Legal and ethical use

Use this actor responsibly and follow Product Hunt's terms and applicable laws.

Do not use exported data for spam, harassment, or prohibited profiling.

Respect privacy when combining this dataset with other sources.

Related scrapers

Explore other Apify actors from our catalog for startup, company, jobs, and social data workflows:

• Y Combinator Companies Scraper for startup/company discovery.
• GitHub Repositories Search Scraper for developer-tool market research.
• LinkedIn Jobs Scraper for hiring and startup-growth signals.

Changelog

Initial version:

• Recent Product Hunt launch extraction.
• Cache-aware output and pricing events.
• Product URL, tagline, date, outbound redirect, and freshness metadata.

Support

If you need additional Product Hunt fields such as maker profiles, comments, votes, or emails, open an issue with a sample workflow and desired output columns.

Data freshness summary

Cached rows are cheaper and faster.

Fresh rows are better for time-sensitive reporting.

Choose the mode that matches your workflow.

Cost summary

This actor is designed for predictable costs:

• no browser by default,
• no proxy by default,
• one Product Hunt feed request per run,
• optional cache reuse,
• per-row charge events.

Final note

Product Hunt Scraper is best for lightweight, repeatable launch monitoring and dataset exports.