# Product Hunt Launches (`s-r/producthunt-launches`) Actor

Pull the Product Hunt leaderboard as rows: rank, product name, URL, slug, tagline, topics, vote count and comment count. Pick the daily, weekly or monthly board for any date back to 2013. Up to 100 launches per run.

- **URL**: https://apify.com/s-r/producthunt-launches.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 run start fees

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: Daily Launches and Upvotes

Hosted **product hunt scraper** that pulls the daily, weekly, or monthly Product Hunt leaderboard as structured JSON, votes, comments, topics, slugs, all clean. Run it from the Apify Store with one click, or call it from your own service via the Apify API. Pay per launch row, not per month.

If you've been searching for an **apify product hunt scraper** that's actually maintained (most existing ones break when Product Hunt ships a React update), or for a **product hunt scraper github** repo that doesn't rot the moment the site ships a UI change, this Actor is the hosted alternative.

### What you get

- **Full leaderboard data**, rank, product name, URL, slug, tagline, topic chips, vote count, comment count.
- **Three time windows**, daily, weekly, or monthly leaderboard from any historical date.
- **Up to 100 launches per run**, covers the full daily leaderboard plus the long tail.
- **Structured JSON output**, clean records ready for analytics, alerts, or pipelines.
- **Pay only for what you scrape**, pricing scales per launch returned. No subscription.

### Why scrape product hunt top products

Product Hunt is the single best signal for what new SaaS, dev tools, AI products, and consumer apps are gaining traction this week. VCs, market researchers, growth teams, and competitive intelligence analysts watch the leaderboard daily for one reason: it's a leading indicator of where attention and capital are about to flow.

But Product Hunt's React-based UI doesn't expose a public API for the leaderboard rankings, and existing **product hunt scraper** open-source repos rot fast, Product Hunt ships UI updates frequently and the maintainers of one-off GitHub scrapers usually move on. This hosted Actor solves both problems: maintained infrastructure, structured output, and nothing for you to operate.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `period` | string | `daily` | Leaderboard period, one of `daily`, `weekly`, `monthly`. |
| `date` | string | `yesterday` | ISO date (`YYYY-MM-DD`) or `yesterday`/`today`. For weekly/monthly the date selects the period containing it. |
| `limit` | integer | `30` | Max launches to return (1–100). |

### Output

Every run pushes results to the Apify dataset as JSON records, one per launch:

```json
{
  "rank": 1,
  "name": "Scholé",
  "url": "https://www.producthunt.com/products/schole-2",
  "slug": "schole-2",
  "tagline": "Turn everyday work into personalized AI learning",
  "topics": ["Artificial Intelligence", "Online Learning"],
  "comments": 34,
  "votes": 273,
  "period": "daily",
  "date": "2026-05-02",
  "leaderboard_url": "https://www.producthunt.com/leaderboard/daily/2026/5/2",
  "fetched_in_seconds": 1.4
}
```

You can:

- **Download** the dataset as JSON, JSONL, CSV, or Excel from the Apify console
- **Stream** results via the Apify API into your CRM, Slack, or analytics warehouse
- **Pipe** to webhooks, S3, BigQuery, or any of Apify's 30+ integrations
- **Diff** today's run against yesterday's to detect new entries and ranking shifts

### Use cases for the product hunt scraper

#### VC deal-flow monitoring

Run the Actor daily and pipe the top 10 launches into a Slack channel. Topic-filter for the categories you invest in (`Artificial Intelligence`, `Developer Tools`, `Productivity`). You'll see new traction signals 24–48 hours before they hit the curated newsletters.

#### Competitive intelligence

If your category is on Product Hunt, schedule a weekly run filtered to your top topics. New entrants ranking above 20 votes are worth a 15-minute teardown, the tagline and topic chips give you their positioning vocabulary cheaply.

#### Content marketing input

Scraping the daily leaderboard for a specific topic (e.g. `Artificial Intelligence`) gives you a constantly-refreshing list of products to write about, comparison guides for, or include in roundups. The taglines surface the exact value props the founders chose to lead with.

#### Trend detection across time

Pull the monthly leaderboard for the past 12 months. The shift in topic-chip distribution (e.g. `AI` rising, `Crypto` falling) is one of the cleanest, most current signals for B2B SaaS thematic trends.

### How it compares

Alternatives are either no-code monitors that need an account and credits, or GitHub scrapers you run and patch yourself as Product Hunt ships UI updates. This Actor is hosted and returns leaderboard rows as JSON per run.

| | No account or key | Hosted for you | JSON output | Usage-based, no monthly plan |
|---|---|---|---|---|
| This Actor | Yes | Yes | Yes | Yes |
| Browse.ai Product Hunt | No, account | Yes | Yes | Credit plans |
| ProductHunt-scraper (GitHub, fernandod1) | Yes | No, you self-host | Yes | Free, but you maintain it |

### FAQ

#### Is this product hunt scraper free?

The Actor itself is hosted on Apify with pay-per-launch pricing, you only pay for the launches you actually receive. There's no monthly subscription. A typical daily-leaderboard run (~25 launches) costs a fraction of a dollar.

#### How does this compare to an open-source product hunt scraper github repo?

Most open-source PH scrapers haven't been updated in 12+ months and break when Product Hunt ships a React UI update. This Actor is hosted, monitored, and patched as PH evolves, you don't run anything yourself.

#### Can I scrape product hunt top products from a specific date?

Yes, pass any ISO date in the `date` field. Daily leaderboards are available going back to PH's launch in 2013. Weekly and monthly use the period containing the date you provide.

#### How fast is it, and will Product Hunt rate-limit me?

A daily leaderboard is a single request and completes in **under two seconds**. Nothing for you to configure, and at one request per run there is no rate limit to work around.

#### How many launches does one run return?

The leading stretch of the board: **16 to 17 launches on a typical weekday**, in rank order from number one. A quiet day returns fewer because fewer launched, not because anything was missed. Saturday 6 September 2026 had seven, and seven is what comes back.

**On Apify's free plan a run is capped at the top 10.** That is the plan's limit rather than the Actor's, and you are billed for what is delivered, not what was read. On any paid plan the full board comes back.

When a board runs longer than one page carries, every row is flagged with `more_beyond_this_page: true`, so a partial list never has to be mistaken for a complete one.

#### Can I get launch detail beyond what's on the leaderboard?

The Actor returns leaderboard data only. If you need per-product detail (full description, maker info, comments, related links), pair it with a follow-up scrape on each launch's `url`.

#### Can I run this on a schedule?

Yes, Apify has built-in scheduling. Most teams schedule a daily run at 00:30 UTC (just after the daily leaderboard locks at midnight UTC) and pipe the result into Slack, Notion, or their CRM.

### Pricing

This product hunt scraper uses Apify's pay-per-event pricing, every successful launch row costs a small fixed amount, so your bill scales linearly with usage. There's no monthly subscription and no minimum spend. See the Apify Store page for the current per-launch price.

# Actor input Schema

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

Daily / weekly / monthly leaderboard.

## `date` (type: `string`):

ISO date (YYYY-MM-DD), or 'yesterday' (default), or 'today'. For weekly/monthly the date selects the week/month containing it.

## `limit` (type: `integer`):

Max launches to return (1–100).

## Actor input object example

```json
{
  "period": "daily",
  "date": "yesterday",
  "limit": 30
}
```

# Actor output Schema

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

One row per launch on the daily / weekly / monthly leaderboard.

## `output` (type: `string`):

OUTPUT record with the run's counts and status flags.

## `errors` (type: `string`):

Failures with a code and a redacted message. Absent when the run had none.

# 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",
    "date": "yesterday",
    "limit": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/producthunt-launches").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",
    "date": "yesterday",
    "limit": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/producthunt-launches").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",
  "date": "yesterday",
  "limit": 30
}' |
apify call s-r/producthunt-launches --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/producthunt-launches"
        }
    }
}
```

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/cJyAhHC4XV65W13jY/builds/RSFhvh0mzTT7GleTA/openapi.json