# Product Hunt Launch & Topic Data Exporter (`nimbryxo-studio/product-hunt-launch-and-topic-data-exporter`) Actor

Export Product Hunt launches with votes, comments, makers, hunter and topics from the daily leaderboard, a topic, a maker's history, or specific product slugs.

- **URL**: https://apify.com/nimbryxo-studio/product-hunt-launch-and-topic-data-exporter.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Launch, Comment & Review Exporter

Collect Product Hunt launches from the **full daily feed**, daily/weekly/monthly/yearly leaderboards, a topic, a category, a keyword search, a list of products, or a list of specific launches. No Product Hunt account, API token, cookie or browser is needed.

Each row is one launch with votes, comments count, rank, hunter, makers, topics, media, website, pricing, review score, and an optional discussion thread, review list, and launch history.

### Modes

| Mode | What it returns |
|---|---|
| `latest` | Today's complete daily feed (falls back to yesterday while today's feed is still empty). Cursor-paginated: a busy day has roughly 700-950 launches, not just the visible top 20. |
| `leaderboard` | One daily, weekly, monthly or yearly leaderboard, cursor-paginated. Pick the period and an optional date. |
| `dailyRange` | Every launch on each day between `from` and `to`, deduplicated across days. |
| `topic` | Products in a topic, resolved to each product's latest launch. |
| `category` | Products in a category, resolved to each product's latest launch. |
| `search` | Product Hunt product search for a keyword, resolved to each product's latest launch. |
| `product` | One or more product slugs/URLs, returning each product's latest launch with full product data. |
| `launch` | One or more launch slugs/URLs, returning those exact launches. |

Turn on `includeDetails` for the full launch page (description, maker/hunter profiles, media, website, pricing, ranks, review score). Turn on `includeComments`, `includeReviews`, and `includeHistory` to attach the discussion thread, detailed reviews, and earlier launches from the same product.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `latest` | `latest`, `leaderboard`, `dailyRange`, `topic`, `category`, `search`, `product`, or `launch`. |
| `period` | select | `daily` | Leaderboard period: `daily`, `weekly`, `monthly`, `yearly`. |
| `date` | string | — | Leaderboard date (`YYYY-MM-DD`). Weekly/monthly/yearly use that day's ISO week, month, or year. |
| `from`, `to` | string | — | Inclusive day range for `dailyRange`. |
| `topicSlugs` | array | `[]` | Topic slugs or `/topics/...` URLs. |
| `categorySlugs` | array | `[]` | Category slugs or `/categories/...` URLs. |
| `searchQuery` | string | – | Keyword for `search`. |
| `productSlugs` | array | `[]` | Product slugs or product URLs. |
| `postIds` | array | `[]` | Launch slugs or launch URLs. |
| `maxItems` | integer | `50` | Record cap, 1-1000. |
| `maxPages` | integer | `10` | Page cap per source, 1-60. A full day is about 40-60 pages of 20 launches. |
| `maxComments` | integer | `50` | Comment cap per launch, 1-500. Threads are read 20 per page. |
| `maxReviews` | integer | `20` | Review cap per product, 1-200. Reviews are read 10 per page. |
| `includeDetails` | boolean | `true` | Fetch the full launch page. |
| `includeComments` | boolean | `false` | Attach comments and nested replies. |
| `includeReviews` | boolean | `false` | Attach detailed reviews, ratings, pros and cons. |
| `includeHistory` | boolean | `false` | Attach the product's earlier launches. |
| `featuredOnly` | boolean | `false` | Keep only homepage-featured launches. |
| `proxyConfiguration` | object | off | Optional. The actor works without a proxy. |

The default prefill reads three latest launches with details on, comments/reviews/history off.

### Output

Every launch row uses camelCase fields and omits empty values entirely (no `null`, no empty strings or arrays):

- **Identity** — `id`, `slug`, `name`, `tagline`, `description`, `url`, `phUrl`, `sourceUrl`, `recordType`, `scrapedAt`
- **Votes and discussion** — `votesCount`, `launchDayScore`, `commentsCount`, `reviewsCount`, `reviewsRating`
- **Rank and timing** — `dailyRank`, `weeklyRank`, `monthlyRank`, `launchNumber`, `featured`, `featuredAt`, `createdAt`, `scheduledAt`, `updatedAt`, `launchState`, `isPromoted`
- **People and taxonomy** — `hunter`, `makers`, `topics`, `topicDetails`
- **Product** — `website`, `websiteDomain`, `pricingType`, `product` (id, slug, name, tagline, website, social links, categories, followers, reviews count/rating, first launch date)
- **Media and badges** — `media` (image/video URL, dimensions, platform), `thumbnailUrl`, `badges`, `promo`
- **Optional arrays** — `comments` (with nested `replies`), `reviews` (ratings, text, pros/cons, reviewer, source launch), `launchHistory`

`phUrl` is the legacy short launch link (`/posts/<slug>`); `url` is the canonical Product Hunt product/launch link. `website` is the product's own site. `pricingType` is Product Hunt's value when present (`free`, `free_options`, `payment_required`) and otherwise a normalized `free`/`paid` from the product's structured data.

### Examples

#### Full feed for one busy day

```json
{
  "mode": "dailyRange",
  "from": "2026-10-25",
  "to": "2026-10-25",
  "maxItems": 1000,
  "maxPages": 60,
  "includeDetails": true
}
```

#### Weekly AI leaderboard with comments

```json
{
  "mode": "leaderboard",
  "period": "weekly",
  "date": "2026-10-26",
  "featuredOnly": true,
  "maxItems": 50,
  "includeComments": true,
  "maxComments": 40
}
```

#### Latest launches in a topic, with reviews

```json
{
  "mode": "topic",
  "topicSlugs": ["artificial-intelligence"],
  "maxItems": 20,
  "includeDetails": true,
  "includeReviews": true,
  "maxReviews": 20
}
```

#### One product with its launch history

```json
{
  "mode": "product",
  "productSlugs": ["notion"],
  "includeDetails": true,
  "includeHistory": true,
  "maxPages": 5
}
```

#### Specific launches by URL

```json
{
  "mode": "launch",
  "postIds": [
    "https://www.producthunt.com/products/strawberry?launch=strawberry-1-0"
  ],
  "includeComments": true,
  "maxComments": 100
}
```

### How it works

The actor uses Product Hunt's public frontend GraphQL endpoint with the same persisted queries the website loads, a desktop browser user agent, `X-Requested-With`, the Product Hunt timezone header, and `apollo-require-preflight`. It sends the full query document plus its sha256 persisted-query hash, so no token or cookie is ever involved.

If Product Hunt ships a new frontend build and a persisted hash stops matching, the actor refreshes the query document from the page's Apollo SSR payload, retries once, and then falls back to the page's embedded JSON state. A 200 response with an empty block is treated as a block or a source fault, never as a successful empty run.

Comments paginate 20 threads per page with reply cursors; reviews paginate 10 per page; launch history paginates 10 per page. Records are deduplicated by launch, comment, and review id.

### Reliability and limits

- Retries with backoff on 429/5xx/timeouts; a Cloudflare challenge produces a failed run with a clear status message instead of an empty dataset.
- `maxItems`, `maxPages`, `maxComments`, and `maxReviews` are hard caps. A day with more launches than `maxItems` stops exactly at the cap.
- Product Hunt's maker profile pages are protected by a challenge, so maker emails and social handles are not part of this dataset. Launch data includes maker names, usernames, headlines, avatars and follower counts when the source exposes them.
- Funding amount and employee count are not reliably exposed by the public product pages and are omitted.
- Very large launches can have hundreds of comments; raise `maxComments` up to 500 for those threads.
- Topic/category/search results are products, so the actor resolves each product's latest launch. Older launches from the same product are available with `includeHistory`.
- Search is product search (the same search the Product Hunt site uses), not a free-text search over historical launch descriptions.

### FAQ

**Do I need a Product Hunt account or API token?**
No. The actor reads the same public frontend data the website renders. There is nothing to sign up for.

**Why do I get more than 20 launches per day?**
The visible leaderboard is a preview. The actor follows the cursor until the source is exhausted, which is normally 700-950 launches on a busy day.

**Are comments and reviews included by default?**
No. They are opt-in because they add requests. Set `includeComments` and/or `includeReviews` to attach them to each launch record.

**What happens if Product Hunt blocks the request?**
The actor retries, optionally rotates your proxy session if you supplied a proxy, and fails the run with a status message. It never reports a blocked or empty page as a successful empty dataset.

**Can I get older launches?**
Yes: set a past `from`/`to` for `dailyRange`, pick a past leaderboard date, use `product` with `includeHistory`, or pass an old launch URL in `launch` mode.

**Is this affiliated with Product Hunt?**
No. This is an independent, third-party exporter that reads Product Hunt's public web data. It is not affiliated with or endorsed by Product Hunt.

# Actor input Schema

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

Pick the launch feed, a leaderboard period, a date range, a topic, a category, a keyword search, specific products, or specific launches.

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

Used when mode is `leaderboard`. Daily = one day, weekly = ISO week, monthly = calendar month, yearly = calendar year.

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

Optional date for mode=leaderboard, in YYYY-MM-DD form. The daily period uses the exact day; weekly, monthly and yearly use that day's ISO week, month or year. Defaults to today.

## `from` (type: `string`):

Optional first day for mode=dailyRange, in YYYY-MM-DD form. Defaults to the `to` date, or yesterday.

## `to` (type: `string`):

Optional last day for mode=dailyRange, in YYYY-MM-DD form. Defaults to the `from` date, or yesterday.

## `topicSlugs` (type: `array`):

Topics for mode=topic, e.g. `artificial-intelligence`, `developer-tools`, or a full `/topics/...` URL.

## `categorySlugs` (type: `array`):

Categories for mode=category, e.g. `ai-code-editors`, `productivity`, or a full `/categories/...` URL.

## `searchQuery` (type: `string`):

Keyword for mode=search, e.g. `notion`, `ai browser`, `invoice`. Product Hunt searches products, then the actor resolves each product's latest launch.

## `productSlugs` (type: `array`):

Products for mode=product, e.g. `notion`, `figma`, or full `https://www.producthunt.com/products/...` URLs. Each product's latest launch is returned.

## `postIds` (type: `array`):

Launches for mode=launch, e.g. `strawberry-1-0`, or full `https://www.producthunt.com/products/...?launch=...` URLs.

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

Stop after this many launch records. One record is one launch (comments and reviews stay attached to it).

## `maxPages` (type: `integer`):

Page cap per feed, topic, category, search query, product history, comment thread or review feed. A full Product Hunt day is about 40-60 pages of 20 launches.

## `maxComments` (type: `integer`):

Used when `includeComments` is on. Comments are read 20 threads per page, including replies, and capped at this number.

## `maxReviews` (type: `integer`):

Used when `includeReviews` is on. Reviews are read 10 per page and capped at this number.

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

Fetch the full launch page for description, hunter, makers, media, website, pricing, ranks and review score. Turn off for a faster, lighter feed.

## `includeComments` (type: `boolean`):

Attach the discussion thread (comments and nested replies) to each launch. Adds one or more requests per launch.

## `includeReviews` (type: `boolean`):

Attach Product Hunt's detailed reviews, ratings, pros and cons to each launch. Adds one request per 10 reviews.

## `includeHistory` (type: `boolean`):

Attach every earlier launch from the same product, newest first.

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

Keep only launches that Product Hunt selected for the homepage.

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

Optional. The actor works without a proxy; add one only if Product Hunt blocks your network or you need a specific location.

## Actor input object example

```json
{
  "mode": "latest",
  "period": "daily",
  "topicSlugs": [],
  "categorySlugs": [],
  "productSlugs": [],
  "postIds": [],
  "maxItems": 3,
  "maxPages": 1,
  "maxComments": 20,
  "maxReviews": 10,
  "includeDetails": true,
  "includeComments": false,
  "includeReviews": false,
  "includeHistory": false,
  "featuredOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing launch records. Comments and reviews are nested arrays on the launch when enabled.

## `products` (type: `string`):

Backward-compatible alias of the same launch dataset.

# 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": "latest",
    "period": "daily",
    "topicSlugs": [],
    "categorySlugs": [],
    "productSlugs": [],
    "postIds": [],
    "maxItems": 3,
    "maxPages": 1,
    "maxComments": 20,
    "maxReviews": 10,
    "includeDetails": true,
    "includeComments": false,
    "includeReviews": false,
    "includeHistory": false,
    "featuredOnly": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/product-hunt-launch-and-topic-data-exporter").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": "latest",
    "period": "daily",
    "topicSlugs": [],
    "categorySlugs": [],
    "productSlugs": [],
    "postIds": [],
    "maxItems": 3,
    "maxPages": 1,
    "maxComments": 20,
    "maxReviews": 10,
    "includeDetails": True,
    "includeComments": False,
    "includeReviews": False,
    "includeHistory": False,
    "featuredOnly": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/product-hunt-launch-and-topic-data-exporter").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": "latest",
  "period": "daily",
  "topicSlugs": [],
  "categorySlugs": [],
  "productSlugs": [],
  "postIds": [],
  "maxItems": 3,
  "maxPages": 1,
  "maxComments": 20,
  "maxReviews": 10,
  "includeDetails": true,
  "includeComments": false,
  "includeReviews": false,
  "includeHistory": false,
  "featuredOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nimbryxo-studio/product-hunt-launch-and-topic-data-exporter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/product-hunt-launch-and-topic-data-exporter"
        }
    }
}
```

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/GAAwZYbMvugYH1EkV/builds/Gt2QpRfveJ3Ze6KsE/openapi.json