# Product Hunt Launches Scraper: Daily Leaderboard & Websites (`manageable_gully/product-hunt-scraper`) Actor

Scrape Product Hunt launches: today's featured launches from the official feed, daily/weekly/monthly leaderboards, topics or launch URLs. Name, tagline, votes, rank, website, makers, topics, ratings. New startups and SaaS websites every day. From $1.20 per 1,000 launches.

- **URL**: https://apify.com/manageable_gully/product-hunt-scraper.md
- **Developed by:** [WebIntel Tools](https://apify.com/manageable_gully) (community)
- **Categories:** Lead generation, Automation, Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 launched products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Launches Scraper: Today's Launches, Daily Leaderboard, New Startups & Websites

Get **Product Hunt launches as clean JSON, CSV or Excel**: today's featured launches from Product Hunt's **official feed**, daily, weekly and monthly leaderboards, topic pages or any list of launch URLs. Each row has the product name, tagline, votes, comments, daily/weekly/monthly rank, topics, thumbnail and launch date, plus optional **details**: website URL and domain, makers and hunter (public names only), categories, rating, followers and description.

Built for **VCs and scouts** (deal flow), **founders** (competitor tracking), **newsletter writers** ("top launches of the week") and **growth teams** (lists of new SaaS websites).

### What you can use it for

- **VCs and scouts:** a daily list of new startups with votes, rank and website, for deal flow.
- **B2B sales and lead lists:** new SaaS websites every day; pair with the [Website Tech Stack Detector](https://apify.com/manageable_gully/website-tech-detector) to qualify them.
- **Founders:** track competitors and every launch in your topic (e.g. `developer-tools`).
- **Newsletter writers:** "top launches of the week" in one run.
- **Market research:** launches per topic and month, with votes and ratings.

### How to use it

1. Choose a **mode**: `feed` (today's launches, default), `leaderboard` (daily/weekly/monthly), `topic` or `urls`.
2. Set the date range and, optionally, topics, keywords and minimum votes.
3. Keep **Include details** on for website, makers and ratings.
4. Click **Start**, or schedule it daily with **Only new launches**.

### Why this scraper

- **Reliable:** the default `feed` mode reads Product Hunt's official Atom feed (today's ~50 featured launches), which works even when the website blocks cloud IPs. If a leaderboard page for today or yesterday is blocked, the run falls back to the feed automatically instead of failing. Plain HTTP, no headless browser, retries with backoff. Residential proxy is off by default (opt in with *Allow residential proxy fallback*).
- **Cheap:** $1.20 per 1,000 launches (listing only) or **$2.50 per 1,000 with details**, no monthly rent. 512 MB memory.
- **Only new launches:** turn on *Only new launches since last run* for daily schedules, and you pay only for launches you haven't seen.
- **Filters:** topics, keywords (name/tagline) and minimum votes. Filtered-out launches are free.
- **Polite and logged out:** never logs in, never creates accounts, follows robots.txt (no `/search`, no `/r/` short links, no user sub-pages), about 1 request per second, slowing down further if Product Hunt pushes back.
- **Privacy-minded:** no emails and no social-profile crawling. Maker data is limited to the public name, username and headline shown on the launch page, and you can switch it off.

### Modes

| Mode | What you get |
|---|---|
| `feed` (default) | Today's ~50 featured launches from Product Hunt's official Atom feed: name, tagline, product link, launch date and hunter. No vote counts or ranks in the feed; turn on *Include details* for website, makers and rating. |
| `leaderboard` | Top launches of every day, week or month in a date range (Pacific Time, Product Hunt's launch day). Featured ranking by default, or the *All* tab ranked by votes. Each leaderboard page gives the top ~17 launches. |
| `topic` | Products listed on topic pages, e.g. `artificial-intelligence`, `developer-tools` (highest rated first, 15 per page). |
| `urls` | Any `https://www.producthunt.com/posts/<slug>` or `/products/<slug>` URLs. |

### Input examples

Today's featured launches from the official feed (the default):

```json
{ "mode": "feed", "maxItems": 50, "includeDetails": false }
```

Yesterday's top launches with votes, ranks and websites:

```json
{ "mode": "leaderboard", "period": "daily", "startDate": "1 day", "maxItems": 100, "includeDetails": true }
```

All AI launches with 200+ votes in September 2026's monthly leaderboard:

```json
{ "mode": "leaderboard", "period": "monthly", "startDate": "2026-09-01", "topics": ["artificial-intelligence"], "minVotes": 200 }
```

Daily schedule that returns only new launches:

```json
{ "mode": "feed", "onlyNewSinceLastRun": true, "dedupeKey": "daily-digest" }
```

### Output

| Field | Description |
|---|---|
| `postId`, `name`, `tagline`, `slug` | Launch identity |
| `launchUrl`, `productUrl`, `productSlug` | Product Hunt links |
| `launchDate` (PT), `featuredAt` | Launch day and timestamp (with its own −07:00/−08:00 offset) |
| `votes`, `launchDayVotes`, `commentsCount` | Engagement |
| `dailyRank`, `weeklyRank`, `monthlyRank` | Leaderboard positions |
| `topics`, `thumbnailUrl` | Topic names and image |
| `websiteUrl`, `websiteDomain`, `launchLink` | Details: the product's own website (direct URL, no redirect) |
| `description`, `categories`, `reviewsRating`, `reviewsCount`, `followersCount`, `productLaunchesCount`, `isNoLongerOnline` | Details: product info |
| `githubUrl`, `twitterUrl`, `linkedinUrl` | Details: company links listed on the product page |
| `makers[]` {name, username, headline, profileUrl}, `hunter` {name, username} | Details: public maker/hunter names (optional) |
| `detailsError` | Set when details could not be loaded (the row is then charged as a basic launch only) |
| `scrapedAt`, `source` | Run time (UTC) and attribution |

```json
{
  "postId": "1274680", "name": "Jockey by TwelveLabs",
  "tagline": "Your entire video library: organized, searchable, understood",
  "launchUrl": "https://www.producthunt.com/posts/jockey-by-twelvelabs-2",
  "productUrl": "https://www.producthunt.com/products/twelvelabs",
  "launchDate": "2026-10-16", "featuredAt": "2026-10-16T00:01:00-07:00",
  "votes": 405, "commentsCount": 29, "dailyRank": 1, "weeklyRank": 2,
  "topics": ["Productivity", "Artificial Intelligence", "Video"],
  "websiteUrl": "https://www.twelvelabs.io", "websiteDomain": "twelvelabs.io",
  "reviewsRating": 5, "reviewsCount": 1,
  "makers": [{ "name": "Jae Lee", "username": "jaelee_", "headline": "Co-founder & CEO", "profileUrl": "https://www.producthunt.com/@jaelee_" }],
  "hunter": { "name": "fmerian", "username": "fmerian" },
  "source": "producthunt.com public page"
}
```

The dataset has three views: **Launches**, **Makers & hunters** and **Ratings & categories**.

### Limits and changelog

- Leaderboards: top ~17 per day/week/month. Topic mode: up to ~1,000 products per topic. Max date range: 366 days per run.
- 1.0 (2026-10-17): first release.

### Pricing

Pay per event, no monthly rent:

- **$0.0012 per launch** saved
- **+$0.0013 per launch for details** (website, makers, rating...), optional

| Example | Cost |
|---|---|
| 1,000 launches, listing only | $1.20 |
| 1,000 launches with details | $2.50 |
| Daily top ~17 launches with details, for 30 days | $1.28 |

You can set a **maximum cost per run** in the run options; the Actor stops cleanly when it is reached. New to Apify? The free plan includes $5 of platform credit every month, so you can try this Actor at no cost.

### API, integrations and AI agents (MCP)

Run it from your own code with the [Apify API](https://docs.apify.com/api/v2) and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/manageable_gully~product-hunt-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d @input.json
```

```python
from apify_client import ApifyClient
run = ApifyClient("<YOUR_APIFY_TOKEN>").actor("manageable_gully/product-hunt-scraper").call(run_input={...})
```

- **No-code:** use the Apify app in **n8n, Make or Zapier** ("Run Actor", then "Get dataset items"), or send results to Google Sheets, Slack or a webhook.
- **AI agents (MCP):** add `https://mcp.apify.com?tools=manageable_gully/product-hunt-scraper` to Claude, Cursor, VS Code or any MCP client and the agent can call this Actor as a tool.
- **Schedules:** run it hourly, daily or weekly from Apify Console.

### FAQ

**Does it need a Product Hunt account?** No. It reads Product Hunt's public Atom feed and public, logged-out pages.

**Why are votes empty in feed mode?** The official feed lists today's featured launches without vote counts. Use `leaderboard` mode for votes and ranks; if Product Hunt blocks the leaderboard page, the run returns the feed's launches instead and says so in the status message.

**Why not the official Product Hunt API?** The API's terms do not allow commercial use without Product Hunt's permission, so this Actor does not use it.

**Is scraping Product Hunt legal?** The Actor collects publicly available, factual launch data without logging in. Note that Product Hunt's website terms prohibit crawling and scraping; you are responsible for how you use the data and for complying with the terms that apply to you. Maker names and usernames are personal data under GDPR. Make sure you have a lawful basis for processing them, or switch off *Include makers*. This Actor is not affiliated with or endorsed by Product Hunt.

**Which time zone are dates in?** Pacific Time, because Product Hunt's launch day starts at 00:01 PT.

**How many launches per leaderboard?** Each daily, weekly or monthly leaderboard page gives its top ~17 launches. Scrape a date range to collect more.

**Can AI agents use it?** Yes. It is available as a tool through the Apify MCP server (`https://mcp.apify.com?tools=manageable_gully/product-hunt-scraper`) and the Apify API, and it returns structured JSON that agents can read directly.

### More tools from WebIntel Tools

- [Website Tech Stack Detector](https://apify.com/manageable_gully/website-tech-detector): BuiltWith/Wappalyzer-style tech stack lookup in bulk
- [Google Jobs Scraper](https://apify.com/manageable_gully/google-jobs-scraper): Google for Jobs listings with salaries and apply links
- [RSS Feed Reader & Monitor](https://apify.com/manageable_gully/rss-feed-reader): read and monitor RSS, Atom and JSON feeds, only new items
- [SEO Audit & Domain Checker](https://apify.com/manageable_gully/website-health-audit): SEO, DNS, SSL and security-header audit for lists of domains

See [all WebIntel Tools Actors](https://apify.com/manageable_gully).

*Made by WebIntel Tools. This Actor was built and is maintained with AI assistance. Report issues on the Issues tab; they are monitored daily.*

# Actor input Schema

## `mode` (type: `string`):

feed = today's ~50 featured launches from Product Hunt's official Atom feed (fast, reliable, no vote counts); leaderboard = launches by date range with votes and ranks; topic = launches in topic feeds; urls = specific /posts/ or /products/ URLs. If a leaderboard page for today/yesterday is blocked, the Actor falls back to the official feed automatically.

## `period` (type: `string`):

Which leaderboard to read for each date in the range: daily (one page per day), weekly (ISO week) or monthly.

## `featuredOnly` (type: `boolean`):

On: Product Hunt's featured leaderboard ranked by daily/weekly/monthly rank. Off: all launches of the period, ranked by votes (the leaderboard's 'All' tab).

## `startDate` (type: `string`):

First day to scrape (YYYY-MM-DD) or relative like '7 days'. Defaults to yesterday in Pacific Time (Product Hunt's launch day).

## `endDate` (type: `string`):

Last day to scrape (inclusive). Empty = same as start date. Max range 366 days.

## `topics` (type: `array`):

Product Hunt topic slugs from the topic URL, e.g. artificial-intelligence, developer-tools. In 'topic' mode: products listed on those topic pages (highest rated first, 15 per page). In 'leaderboard' mode: keep only launches tagged with one of these topics.

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

Keep only launches whose name or tagline contains any of these words (case-insensitive). Filtering is local; PH search is not used.

## `minVotes` (type: `integer`):

Skip launches with fewer upvotes than this.

## `startUrls` (type: `array`):

Used in 'urls' mode. Accepts https://www.producthunt.com/posts/<slug> and /products/<slug> (optionally ?launch=<slug>).

## `includeDetails` (type: `boolean`):

Opens each launch's product page. Charged as an extra 'launch-details' event.

## `includeMakers` (type: `boolean`):

Public maker and hunter names, usernames and headlines as shown on the launch page. Never emails or social profiles. Turn off to keep personal data out of your dataset.

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

Skips launches already returned by a previous run with the same 'dedupeKey'. Great for daily schedules.

## `dedupeKey` (type: `string`):

Name of the persistent store for dedupe state. Use different keys for different schedules.

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

Hard cap on dataset rows (and therefore cost). 0 = no cap besides your run's max charge. Each leaderboard page shows the top ~17 launches of that day/week/month.

## `maxConcurrency` (type: `integer`):

How many pages are fetched in parallel. Requests are also paced to about 1 per second (slower if Product Hunt pushes back).

## `proxyConfiguration` (type: `object`):

Not needed in most cases (plain HTTP works). If Product Hunt starts blocking, the Actor switches to Apify residential proxy automatically (see below).

## `allowResidentialFallback` (type: `boolean`):

Off by default. If on and Product Hunt keeps blocking (6 blocked requests in a row), continue through Apify residential proxy (extra proxy cost, capped: details are paused if it gets expensive). Leaving it off keeps the run cheap; blocked leaderboards for today/yesterday fall back to the official feed.

## Actor input object example

```json
{
  "mode": "feed",
  "period": "daily",
  "featuredOnly": true,
  "startDate": "1 day",
  "topics": [
    "artificial-intelligence"
  ],
  "minVotes": 0,
  "startUrls": [
    {
      "url": "https://www.producthunt.com/posts/jockey-by-twelvelabs-2"
    }
  ],
  "includeDetails": true,
  "includeMakers": true,
  "onlyNewSinceLastRun": false,
  "dedupeKey": "default",
  "maxItems": 100,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "allowResidentialFallback": false
}
```

# Actor output Schema

## `results` (type: `string`):

One item per Product Hunt launch: name, tagline, votes, ranks, topics, links and optional details (makers, website, rating).

## `summary` (type: `string`):

Run statistics (launches, details, HTTP stats, estimated proxy cost).

# 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 = {
    "mode": "feed",
    "startDate": "1 day",
    "topics": [
        "artificial-intelligence"
    ],
    "startUrls": [
        {
            "url": "https://www.producthunt.com/posts/jockey-by-twelvelabs-2"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("manageable_gully/product-hunt-scraper").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 = {
    "mode": "feed",
    "startDate": "1 day",
    "topics": ["artificial-intelligence"],
    "startUrls": [{ "url": "https://www.producthunt.com/posts/jockey-by-twelvelabs-2" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("manageable_gully/product-hunt-scraper").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 '{
  "mode": "feed",
  "startDate": "1 day",
  "topics": [
    "artificial-intelligence"
  ],
  "startUrls": [
    {
      "url": "https://www.producthunt.com/posts/jockey-by-twelvelabs-2"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call manageable_gully/product-hunt-scraper --silent --output-dataset

```

## MCP server setup

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

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/liaZXRHJ3yNoaZyaw/builds/JoTxBcFl3ix1UQKA1/openapi.json