# Product Hunt Scraper & API - Daily Launches, Leaderboard, Leads (`rel8ble/product-hunt-scraper`) Actor

Product Hunt scraper and API for daily, weekly, monthly or yearly leaderboards. One result = one launch: rank, name, tagline, votes, comments, topics, real website URL, plus description, X/LinkedIn/GitHub links, reviews, followers. Startup leads, no login, no start fee. $0.70 per 1,000.

- **URL**: https://apify.com/rel8ble/product-hunt-scraper.md
- **Developed by:** [Giovanni Rich](https://apify.com/rel8ble) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.70 / 1,000 results

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 Scraper & API - Daily Launches, Leaderboard, Leads

This **Product Hunt scraper** is a **Product Hunt launches** scraper and unofficial **Product Hunt API**: pick a day, a date range, a week, a month or a year and get the launches from that **Product Hunt leaderboard** as clean JSON, CSV or Excel. One row per launch: rank, name, tagline, score, comment count, topics, launch date and the product's **real website URL and domain**, plus company details from its Product Hunt page: description, X / LinkedIn / GitHub / app store links, reviews, followers and categories - ready for **startup lead generation**.

It reads the same data the Product Hunt website loads, over plain HTTP with **no headless browser** and no login: every launch of a full day (about 900 products) with websites in around 4 minutes. Use it for startup leads, new-product monitoring, competitor and market research, newsletter curation, investor deal flow and feeding AI agents with fresh launch data.

### What you get

One dataset item per launch:

- **Ranking**: `rank` (the rank on the leaderboard you asked for), `dailyRank`, `weeklyRank`, `monthlyRank`, `score`, `launchDayScore`, `commentsCount`.
- **Launch**: `name`, `tagline`, `topics`, `launchedAt` (ISO timestamp), `launchId`, `slug`, `thumbnailUrl`.
- **Links**: `websiteUrl` and `websiteDomain` (the product's own site, tracking parameters removed), `launchUrl` and `productHuntUrl` on Product Hunt.
- **Context**: `leaderboardPeriod`, `leaderboardDate` (`2026-10-10`, `2026-W41`, `2026-09` or `2025`), `leaderboardUrl`, `scrapedAt`.

With **Website and company details** on (default) each launch also has:

- `description` (the full product description), `companyWebsiteUrl`, `companyDomain`.
- `twitterUrl`, `linkedinUrl`, `facebookUrl`, `instagramUrl`, `githubUrl`, `iosUrl`, `androidUrl` (the company's own profiles, when it lists them).
- `reviewsRating`, `reviewsCount`, `followersCount`, `categories`.
- `launchesCount`, `firstLaunchAt` (is this a first launch or the tenth?), `wasInYCombinator`, `isNoLongerOnline`, `makersCount`, `logoUrl`.

People are not returned: no maker or hunter names, profiles or avatars. This is company data.

A `RUN_SUMMARY` record in the key-value store lists per-leaderboard counts, pages read and why each one stopped.

### Sample output

From a real cloud run (daily leaderboard, 2026-10-10):

| rank | name | websiteDomain | score | commentsCount | followersCount |
|---|---|---|---|---|---|
| 1 | Onepin | onepin.ai | 442 | 76 | 1495 |
| 2 | ReSO AI | resollm.ai | 462 | 37 | 1081 |
| 3 | Claude Dashboards & Motion | claude.com | 246 | 5 | 280 |

### Use cases

- **Startup lead generation**: every day about 900 new products launch, each with a website. Export them, keep the topics you sell to, and pass the domains to an email or contact finder.
- **Agency and SaaS prospecting**: new launches need design, SEO, analytics, hosting, payments. `firstLaunchAt` + `launchesCount` tell you who is brand new.
- **Market and competitor monitoring**: schedule a daily run and watch a topic ("Sales", "Developer Tools", "Artificial Intelligence").
- **Investor deal flow**: top launches per week or month with scores, followers and the Y Combinator flag.
- **Newsletters and content**: the top 10 of the day or week with taglines and links, ready to paste.
- **AI agents**: a small, predictable JSON row per product that an agent can read without a browser.

### Pricing

**$0.70 per 1,000 launches** (pay per result; failed requests are never charged). Company details, websites and social links are included at the same price, with no add-on events. The most-used Product Hunt scrapers on the Store charge $0.75-$1.80 per 1,000, and some add a start fee or a second charge for extra data.

| You scrape | You pay |
|---|---|
| 100 launches | $0.07 |
| 1,000 launches | $0.70 |
| 10,000 launches | $7.00 |
| 100,000 launches | $70.00 |

No start fee. The Apify free plan's $5 monthly credit covers about 7,000 launches. A whole day (about 900 launches with details) costs about $0.63. The prefilled input (yesterday's top 10) costs $0.007 and took 35 seconds in a cloud test. If you set a maximum cost per run, the scraper stops cleanly when it reaches it.

#### Why this one

- **The cheapest of the most-used Product Hunt scrapers**: $0.70 per 1,000, against $1.80 (maximedupre), $0.80 + $0.01 per run + $1.00 per 1,000 for extra data (memo23) and $0.75 + maker / e-mail add-ons (fatihtahta).
- **Company details in the same row**: description, X / LinkedIn / GitHub / app store links, reviews, followers, categories and the Y Combinator flag.
- **The real website**: `websiteUrl` and `websiteDomain` with tracking parameters removed, ready for a contact finder.
- **Any period back to 2013**: daily, weekly, monthly or yearly leaderboards, up to 400 per run.
- **Company data only**: no maker or hunter personal data.

### FAQ

**Is it legal? Does it return personal data?**
It reads public Product Hunt pages and returns company data only: maker and hunter names and profiles are left out on purpose (`makersCount` is only a number). You are responsible for how you use the results. This is not legal advice.

**Is this the official Product Hunt API? Does it need a login?**
No. It is an independent tool that reads public pages. It needs no Product Hunt account or API key.

**How fast is it and how many launches can I get?**
Every launch of a full day (about 900) with websites takes around 4 minutes; turning details off is about 5x faster. One run reads up to 400 leaderboards, back to November 2013.

**Which proxy does it need?**
The default Apify Proxy. Product Hunt sits behind Cloudflare, so some requests are challenged and retried on another IP (free); in testing 992 of 992 requests on a full-day run succeeded. Switch to RESIDENTIAL only if the log shows repeated blocks.

**Can I schedule it or use it via API?**
Yes. Run it every morning with empty dates to get yesterday's launches (daily leaderboards do not overlap; use `launchId` as the unique key if you combine periods). It also works from the REST API, Make, Zapier, n8n and the Apify MCP server for AI agents.

**How do I get only AI or only developer tools?**
Filter the output on `topics` (launch tags) or `categories`. Both are plain string arrays.

**Why is `websiteUrl` different from `companyWebsiteUrl`?**
`websiteUrl` is the link of that launch (it can be a feature page such as `together.ai/link`). `companyWebsiteUrl` is the product's main site. For most launches they are the same.

### Example inputs for common jobs

Copy one into the JSON tab of the input and adjust.

Daily lead list: every launch from yesterday (about 900) with websites and social links, ready for a contact finder (about $0.63):

```json
{ "period": "daily", "maxItemsPerLeaderboard": 1000, "includeDetails": true }
```

Newsletter or deal-flow digest: the top 20 of each week in October, featured launches only:

```json
{ "period": "weekly", "startDate": "2026-10-01", "endDate": "2026-10-31", "maxItemsPerLeaderboard": 20, "featuredOnly": true }
```

Fast ranking-only export for research: the top 50 of every month this year, no details (about 5x faster):

```json
{ "period": "monthly", "startDate": "2026-01-01", "endDate": "2026-10-31", "maxItemsPerLeaderboard": 50, "includeDetails": false }
```

Enrich products you already know (one detailed row each):

```json
{ "productUrls": ["notion", "https://www.producthunt.com/products/linear"] }
```

### How to use

1. Choose a **Leaderboard period** (daily is the default) and a **Start date** / **End date**. Leave the dates empty to get yesterday's launches.
2. Set **Max launches per leaderboard** (default 20). Set 1000 to get every launch of a day, not only the top ones.
3. Leave **Website and company details** on if you want websites and social links (you do for lead lists). Turn it off for a fast ranking-only export.
4. Click **Start**. Download the results as JSON, CSV, Excel or HTML from the **Output** tab, or pull them through the Apify API, Make, Zapier, n8n or an MCP client.

Already know the products? Paste Product Hunt product URLs or slugs into **Product URLs or slugs** and get one detailed row per product instead.

### Input example

```json
{
    "period": "daily",
    "startDate": "2026-10-01",
    "endDate": "2026-10-07",
    "maxItemsPerLeaderboard": 50,
    "includeDetails": true,
    "featuredOnly": false
}
```

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `period` | string | `daily` | `daily`, `weekly`, `monthly` or `yearly` leaderboards. |
| `startDate`, `endDate` | string | yesterday | `YYYY-MM-DD`, Pacific time. A range reads every leaderboard of the chosen period it touches (up to 400 per run). |
| `maxItemsPerLeaderboard` | integer | `20` | Launches saved per leaderboard, in leaderboard order. 1000 = a whole day. Max 10000. |
| `includeDetails` | boolean | `true` | Adds website, domain, description, social links, reviews, followers, categories. Off = ranking data only, about 5x faster. |
| `featuredOnly` | boolean | `false` | Only launches Product Hunt featured on its homepage. |
| `leaderboardUrls` | array | empty | Leaderboard URLs such as `https://www.producthunt.com/leaderboard/monthly/2026/9`. |
| `productUrls` | array | empty | Product URLs, launch URLs or slugs (`notion`): one detailed row per product. |
| `maxConcurrency`, `maxRequestRetries`, `proxyConfiguration` | | `5`, `15`, Apify Proxy | Advanced. Defaults work. |

With an empty input the actor returns the top 20 launches of yesterday with websites.

### Output example

A real row from a cloud run (description shortened):

```json
{
    "rank": 1,
    "name": "Onepin",
    "tagline": "AI voiceover with every name, price and date said right",
    "websiteUrl": "https://onepin.ai/",
    "websiteDomain": "onepin.ai",
    "score": 442,
    "launchDayScore": 430,
    "commentsCount": 76,
    "topics": ["Developer Tools", "Artificial Intelligence", "Audio"],
    "launchedAt": "2026-10-10T07:01:00.000Z",
    "dailyRank": 1,
    "weeklyRank": 7,
    "monthlyRank": 9,
    "launchId": "1257662",
    "slug": "onepin",
    "productSlug": "onepin",
    "launchUrl": "https://www.producthunt.com/posts/onepin",
    "productHuntUrl": "https://www.producthunt.com/products/onepin",
    "thumbnailUrl": "https://ph-files.imgix.net/25268265-e582-4351-8a6e-1f94e6959d71.png",
    "description": "AI voices sound human now. But they still guess names from the spelling, and nobody has time to listen to every line. Onepin runs on the voices you already use (ElevenLabs, OpenAI, Google, 30+ more)...",
    "companyWebsiteUrl": "https://onepin.ai/",
    "companyDomain": "onepin.ai",
    "twitterUrl": "https://x.com/onepinai",
    "linkedinUrl": null,
    "facebookUrl": null,
    "instagramUrl": null,
    "githubUrl": null,
    "iosUrl": null,
    "androidUrl": null,
    "reviewsRating": null,
    "reviewsCount": 0,
    "followersCount": 1495,
    "categories": ["Voice AI Tools"],
    "launchesCount": 1,
    "firstLaunchAt": "2026-10-10T07:01:00.000Z",
    "wasInYCombinator": false,
    "isNoLongerOnline": false,
    "makersCount": 1,
    "logoUrl": "https://ph-files.imgix.net/25268265-e582-4351-8a6e-1f94e6959d71.png",
    "leaderboardPeriod": "daily",
    "leaderboardDate": "2026-10-10",
    "leaderboardUrl": "https://www.producthunt.com/leaderboard/daily/2026/10/10",
    "scrapedAt": "2026-10-11T17:41:46.088Z"
}
```

Fill rates measured on 934 launches (every launch of 7 October 2026): website, domain, description, followers, launch counts 100%; X profile 29%; GitHub 9%; LinkedIn 5%; categories 13%. On the top 50 of four days: X 54%, GitHub 24%, LinkedIn 13%, categories 72%. Small first-time launches list fewer links than featured ones.

### API example

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("rel8ble/product-hunt-scraper").call(run_input={"period": "weekly", "maxItemsPerLeaderboard": 100, "includeDetails": True})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rank"], item["name"], "|", item["websiteDomain"], "|", item["score"])
```

One HTTP call that runs the actor and returns the rows (curl):

```bash
curl -X POST "https://api.apify.com/v2/acts/rel8ble~product-hunt-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"period": "daily", "maxItemsPerLeaderboard": 20}'
```

### Integrations

- **API**: `POST https://api.apify.com/v2/acts/rel8ble~product-hunt-scraper/run-sync-get-dataset-items?token=...` with the input JSON returns the rows in one call.
- **Schedules**: run it every morning with empty dates to get yesterday's launches into Google Sheets, Airtable, Slack or a webhook.
- **Make, Zapier, n8n**: use the Apify app, pick this actor, map the dataset rows.
- **MCP / AI agents**: available through the Apify MCP server. Input is small and typed; an empty input is valid.

### Limits (read before large runs)

- Product Hunt sits behind Cloudflare. Some requests are challenged and retried on another IP; you will see retry warnings in the log. That is expected and free. In testing every request eventually succeeded (992 of 992 on a full-day run).
- Leaderboard order is Product Hunt's own. On the "all launches" view the order is close to, but not exactly, final rank; the `rank` field is the true rank.
- `rank` on a yearly leaderboard is the position in the list (Product Hunt publishes no yearly rank number).
- Scores change for a few days after launch. Run again later for final numbers.
- One run reads at most 400 leaderboards. Split longer daily ranges, or use weekly / monthly periods.
- Not included: comments, reviews text, maker and hunter profiles, upvoter lists, email addresses. For emails, pass `websiteDomain` to a contact finder such as [Website Contact Scraper](https://apify.com/rel8ble/website-contact-extractor).

### How it works (for developers)

Each leaderboard starts with one GET of the public leaderboard page; the launches are read from the JSON the page embeds for its own rendering. Following pages are requested the way the site's own client does it: the page's GraphQL document is sent back with its SHA-256 (the persisted-query protocol) and the next cursor, 17 launches per call. Company details use the product page's own header document the same way, one small JSON call per product (about 10 KB instead of a 1 MB page); if that document is refused, the actor falls back to the full product page. Requests run through a small pool of proxy sessions so an IP that passes Cloudflare is reused and a challenged one is dropped. Results are pushed with `Actor.pushData(item, 'result')`, one charge event per saved launch.

# Actor input Schema

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

Which Product Hunt leaderboard to read for the dates below. "daily" (default) = one leaderboard per day, best for fresh launch leads. "weekly" / "monthly" / "yearly" = the top launches of each week, month or year the date range touches. Each leaderboard returns up to maxItemsPerLeaderboard launches, best first.

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

Optional. First day to cover, as YYYY-MM-DD (e.g. 2026-10-01). Product Hunt days run on Pacific time. Leave both dates empty to get yesterday's launches (the latest finished day). Leaderboards exist back to November 2013. Typical cost: top 20 launches per day x 30 days = 600 results = $0.60; every launch of one day is about 900 results = $0.90.

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

Optional. Last day to cover, as YYYY-MM-DD. Empty = same as the start date (one leaderboard). A range reads every daily / weekly / monthly / yearly leaderboard it touches, newest first, up to 400 leaderboards per run.

## `maxItemsPerLeaderboard` (type: `integer`):

How many launches to save from each leaderboard, in Product Hunt's leaderboard order (top launches first). Default 20. A normal weekday has 500-1,000 launches in total, most of them not featured; set 1000 to get a whole day. You pay per saved launch, so this is your cost control. Maximum 10000.

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

On (default): each launch gets websiteUrl and websiteDomain (the product's own site, e.g. https://busabase.com/) plus company details from Product Hunt: full description, X / LinkedIn / Facebook / Instagram / GitHub / App Store / Google Play links, review rating and count, followers, categories, number of launches, first launch date and Y Combinator flag. This is what you need for lead lists and enrichment. Off = leaderboard data only (rank, name, tagline, score, comments, topics, Product Hunt URLs), about 5x faster. Same price per result either way. People (makers, hunters) are never returned.

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

Optional. Off (default) = every launch of the period, as on Product Hunt's "All" tab. On = only the launches Product Hunt featured on its homepage (fewer, higher quality).

## `leaderboardUrls` (type: `array`):

Optional. Product Hunt leaderboard URLs, one per line, e.g. https://www.producthunt.com/leaderboard/daily/2026/10/9 or https://www.producthunt.com/leaderboard/monthly/2026/9. Can be combined with dates.

## `productUrls` (type: `array`):

Optional. Use this when you already know the products: Product Hunt product URLs (https://www.producthunt.com/products/notion), launch URLs (https://www.producthunt.com/posts/...) or slugs (notion), one per line. One result per product with the full company details and its latest launch. Not affected by the date or leaderboard settings.

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

Optional. Parallel requests. Default 5; lower it if you see retries in the log.

## `maxRequestRetries` (type: `integer`):

Optional. How many times a blocked or failed request is retried on a fresh IP before it is given up. Product Hunt sits behind Cloudflare, so retries are normal and free: failed requests are never charged. Default 15.

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

Optional. Default = Apify Proxy (automatic). Switch to the RESIDENTIAL group only if the log shows repeated Cloudflare blocks; it costs more platform credit.

## Actor input object example

```json
{
  "period": "daily",
  "maxItemsPerLeaderboard": 10,
  "includeDetails": true,
  "featuredOnly": false,
  "maxConcurrency": 5,
  "maxRequestRetries": 15,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `launches` (type: `string`):

All launches found: rank, name, tagline, website URL and domain, score, comments, topics, launch date, Product Hunt links and, when requested, company details.

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

Per-leaderboard counts, pages read, stop reasons, and how many websites or detail pages could not be read.

# 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 = {
    "period": "daily",
    "maxItemsPerLeaderboard": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rel8ble/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 = {
    "period": "daily",
    "maxItemsPerLeaderboard": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rel8ble/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 '{
  "period": "daily",
  "maxItemsPerLeaderboard": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rel8ble/product-hunt-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rel8ble/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/5MeZ9JlZ1NMwdet3h/builds/SMFl71KqKViGpGdg8/openapi.json