# Product Hunt Scraper (official API): launches, leaderboard (`brenton8907/product-hunt-data`) Actor

Returns Product Hunt posts as structured rows: daily launches and leaderboards, topic feeds, votes, rank, makers, hunter, media, resolved website and comments, plus a new-launches monitor mode. Official Product Hunt API, so no anti-bot failures. Pay per result.

- **URL**: https://apify.com/brenton8907/product-hunt-data.md
- **Developed by:** [Brenton Keller](https://apify.com/brenton8907) (community)
- **Categories:** Lead generation, Marketing, Agents
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 post records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Product Hunt Scraper (Official API): launches, votes, makers, comments

Daily launches and leaderboards, topic feeds, full post details and comments from **Product Hunt**, built on the **official Product Hunt API** instead of scraping the website. producthunt.com sits behind a bot challenge, which is why scraper-based actors fail a quarter of their runs. This actor talks to the API, so runs finish.

### What it does

- **Launches by date**: every featured post for a day, a range of days, or the last N days, ordered by leaderboard rank, votes, or time.
- **Topic feeds**: filter launches by topic slug (artificial-intelligence, developer-tools, saas, productivity, ...). List all topics with mode "Topics".
- **Specific posts**: by Product Hunt URL or slug, or find a product's launch by its website URL.
- **Full post details** in one row: votes, comments count, daily/weekly/monthly rank, tagline, description, topics, makers (with Twitter and websites), hunter, thumbnail and media, product links, reviews rating.
- **Resolved product website**: Product Hunt's redirect link is followed to the real URL with tracking parameters stripped.
- **Comments** (optional, extra API calls): top comments by votes with author and timestamp.
- **Monitor mode**: remembers posts between runs and outputs only new launches, posts whose votes moved by at least N, or whose rank changed. Schedule it for a "what's new on Product Hunt" feed.

### Who it's for

- Founders and marketers tracking competitors, categories, and launch-day performance.
- Sales and lead generation: makers of new products, with their websites and social handles, filtered by topic.
- Investors, analysts and newsletter writers who need the daily leaderboard as data, not a web page.
- AI agents that want a scheduled, changes-only feed of new launches in a niche.

### Input examples

**Today's leaderboard (default):**

```json
{ "days": 1, "order": "ranking" }
```

**Last 7 days of AI launches with at least 100 votes:**

```json
{ "days": 7, "topics": ["artificial-intelligence"], "minVotes": 100, "order": "votes" }
```

**A specific month, developer tools, with top 20 comments each:**

```json
{ "dateFrom": "2026-08-01", "dateTo": "2026-08-31", "topics": ["developer-tools"], "includeComments": true, "commentsLimit": 20, "maxItems": 300 }
```

**Specific posts, or a product by website:**

```json
{ "mode": "posts", "postUrls": ["https://www.producthunt.com/posts/notion-3-0"], "websiteUrls": ["https://linear.app"] }
```

**Monitor: run hourly, only report new launches or posts that gained 25+ votes:**

```json
{ "days": 1, "changesOnly": true, "minVoteDelta": 25, "monitorStoreName": "ph-today" }
```

The first monitor run outputs every post in the window (all are new) and seeds the store. Later runs output only changes.

**List topics:**

```json
{ "mode": "topics", "topicQuery": "design", "maxItems": 50 }
```

### Output

One row per post.

| Field | Description |
|---|---|
| `id`, `slug`, `url`, `name`, `tagline`, `description` | Post identity and copy |
| `website` | Product Hunt redirect link as returned by the API |
| `website_resolved` | The real product URL after following the redirect (tracking stripped); null if it could not be resolved |
| `votes`, `comments_count`, `reviews_count`, `reviews_rating` | Engagement |
| `daily_rank`, `weekly_rank`, `monthly_rank` | Leaderboard positions (null when not ranked) |
| `launch_date`, `created_at`, `featured_at`, `is_featured` | Timing (UTC) |
| `topics`, `topic_names` | Topic slugs and names |
| `makers` | List of `{ id, name, username, headline, twitter, website, url }`; `maker_count` |
| `hunter_name`, `hunter_username`, `hunter_url` | Who submitted the post |
| `thumbnail_url`, `media` | Thumbnail and gallery items `{ type, url, video_url }` |
| `product_links` | `{ type, url }` such as app store links |
| `comments` | With `includeComments`: `{ id, body, created_at, votes, url, parent_id, user_name, user_username, user_headline }` |
| `is_new`, `previous_votes`, `previous_seen_at`, `votes_delta`, `rank_changed` | Monitor mode only |
| `enrichment_error` | Set if the comments call failed; the base row is still returned and billed at the base rate |
| `raw` | With `includeRaw`: the untouched API object |
| `fetched_at` | When the row was fetched (UTC) |

Topics mode rows: `id`, `name`, `slug`, `description`, `url`, `followers_count`, `posts_count`, `created_at`.

### Pricing

Pay per result. You are charged only for rows written to the dataset.

| Event | Price | When |
|---|---|---|
| Post record | $1.00 per 1,000 rows | Standard run |
| Enriched post record | $3.00 per 1,000 rows | Row has comments attached (`includeComments`) |
| Topic record | $0.50 per 1,000 rows | Topics mode |

Examples: a day's leaderboard (about 50 to 100 posts) costs under $0.10. A month of developer-tools launches with comments (300 rows) costs $0.90. A monitor run that finds 8 changed posts costs $0.008.

Rows are billed by what they contain: a post whose comments call failed is billed at the base rate. The first run in monitor mode charges every row, because every post is new to the store. Set **Maximum total charge** on the run to cap spend; the actor stops cleanly at the cap.

### Limits and notes

- Product Hunt's API allows 6,250 complexity points per 15 minutes per token. A page of 20 posts with makers and topics costs a few hundred points, so roughly 300 to 600 posts per 15-minute window. The actor reads the rate-limit headers and waits for the window to reset (up to `maxWaitSecs`, default 15 minutes) instead of failing. For large backfills, pass your own token (`accessToken`) to get your own quota.
- The API filters by one topic server-side; additional topics are matched client-side against each post's topics.
- The API defaults `postedAfter` to one month ago; the actor always sends explicit bounds, so older date ranges work.
- `website_resolved` follows Product Hunt's redirect with a plain HTTP client; a small share of products (bot-protected sites) resolve to null.
- Monitor state is per `monitorStoreName`. Do not run two monitor runs against the same store at the same time.
- Data comes from Product Hunt's official API under its terms; do not use it to spam makers.

### Use from an AI agent (MCP)

Every Apify actor is available as a tool through the [Apify MCP server](https://mcp.apify.com). Suggested agent pattern: schedule a run with `changesOnly: true` and a topic, then act only on the rows returned.

### Support

Open an issue on the actor page with the run ID and input.

# Actor input Schema

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

Launches: posts in a date window (leaderboard). Posts: specific posts by URL/slug or by product website. Topics: list topics.

## `days` (type: `integer`):

Launches mode: how many days up to today (or up to 'Date to'). Ignored when 'Date from' is set. 1 = today's launches.

## `dateFrom` (type: `string`):

Launches mode: first day (UTC), YYYY-MM-DD. Overrides 'Days back'.

## `dateTo` (type: `string`):

Launches mode: last day (UTC), YYYY-MM-DD. Defaults to today.

## `order` (type: `string`):

Order of posts before 'Max posts' is applied.

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

Only posts featured on the homepage (the leaderboard). Turn off to include every submitted post.

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

Topic slugs, e.g. artificial-intelligence, developer-tools, productivity, saas. Find slugs with mode 'Topics'.

## `searchQueries` (type: `array`):

Case-insensitive keywords matched against name, tagline, description and topic names.

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

Drop posts below this vote count.

## `postUrls` (type: `array`):

Posts mode: producthunt.com/posts/<slug> URLs or bare slugs.

## `websiteUrls` (type: `array`):

Posts mode: find Product Hunt posts by the product's website URL (exact match as submitted).

## `topicQuery` (type: `string`):

Topics mode: filter topics by name.

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

Cap on dataset rows, applied after filtering and sorting.

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

Attach top comments per post (extra API calls). Billed as enriched record.

## `commentsLimit` (type: `integer`):

How many comments (by votes) to attach when 'Include comments' is on.

## `resolveWebsites` (type: `boolean`):

Follow Product Hunt's redirect link to the real product URL (tracking parameters stripped).

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

Used only to follow producthunt.com/r/... redirects to the real product website (the site blocks datacenter IPs). The API calls never use a proxy. A resolution is a few KB, so residential usage is negligible.

## `changesOnly` (type: `boolean`):

Remember posts between runs and output only new launches, posts whose votes moved at least 'Min vote change', or whose daily rank changed. Schedule the actor for a clean 'what's new' feed.

## `minVoteDelta` (type: `integer`):

Monitor mode: minimum vote change to report a post already seen.

## `monitorStoreName` (type: `string`):

Named key-value store that holds the last-seen snapshot. Use different names for different watchlists.

## `accessToken` (type: `string`):

Optional. A developer token or client-level token from api.producthunt.com/v2/oauth/applications. Using your own token gives you your own rate-limit quota (6,250 complexity points per 15 minutes).

## `maxWaitSecs` (type: `integer`):

If Product Hunt's rate limit is hit, wait up to this long for the window to reset before failing.

## `includeRaw` (type: `boolean`):

Attach the untouched upstream post object under 'raw'.

## Actor input object example

```json
{
  "mode": "launches",
  "days": 1,
  "order": "ranking",
  "featuredOnly": true,
  "topics": [
    "artificial-intelligence"
  ],
  "minVotes": 0,
  "maxItems": 100,
  "includeComments": false,
  "commentsLimit": 20,
  "resolveWebsites": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "changesOnly": false,
  "minVoteDelta": 10,
  "monitorStoreName": "product-hunt-monitor",
  "maxWaitSecs": 900,
  "includeRaw": false
}
```

# Actor output Schema

## `posts` (type: `string`):

One record per Product Hunt post. In monitor mode only new launches or vote changes are emitted.

# 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 = {
    "topics": [
        "artificial-intelligence"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("brenton8907/product-hunt-data").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 = {
    "topics": ["artificial-intelligence"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("brenton8907/product-hunt-data").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 '{
  "topics": [
    "artificial-intelligence"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call brenton8907/product-hunt-data --silent --output-dataset

```

## MCP server setup

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

```

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/93eK8I1moc7evtmLj/builds/l299KPYa5angbINDb/openapi.json