# Product Hunt Scraper - Launches, Maker Emails & Socials (`weighty_nimbleness/product-hunt-launches`) Actor

Scrape full Product Hunt leaderboards (daily, weekly, monthly), product URLs and topic pages: rank, upvotes, makers, website, plus public emails and X/LinkedIn/GitHub links from each product site. For startup lead lists, VC deal flow and competitor tracking. No login or API key.

- **URL**: https://apify.com/weighty_nimbleness/product-hunt-launches.md
- **Developed by:** [John Soh](https://apify.com/weighty_nimbleness) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 - Launches, Maker Emails & Socials

Get every Product Hunt launch as a clean row: name, tagline, rank, upvotes, comments, topics, makers (with profile links), the real product website, and, if you turn on **contacts**, the public emails and X / LinkedIn / GitHub links published on that website. It covers the full daily, weekly and monthly leaderboards (every page, not just the top 17), optionally every non-featured launch too, any list of product URLs, and Product Hunt topic pages. No Product Hunt login or API key needed.

**Pricing is flat and predictable:** $1.50 per 1,000 launches. Turn on contacts and you pay $2 per 1,000 more, **only for launches where the crawl actually finds an email or a social link**. A launch with contacts found costs at most $3.50 per 1,000; on the 2026-10-20 daily board (33 launches, 27 with an email or social) the whole run came to about $3.14 per 1,000. Emails and socials come in that one price, with no extra fee per email. Apify's free $5 monthly credit covers at least 1,400 launches with contacts on, or about 3,300 without.

### What people use it for

| You are... | Run it like this | What you get |
|---|---|---|
| **Agency or freelancer selling to new startups** (dev shops, design, SEO, launch marketing) | Daily schedule, `period: daily`, contacts on, then Google Sheets or your CRM | A fresh list every morning of companies that just launched, with a website, any published contact email and the company's X / LinkedIn |
| **VC scout, angel or accelerator** | Weekly board with `topic: artificial-intelligence` (or fintech, developer-tools) | A weekly deal-flow sheet ranked by upvotes, with the makers' names |
| **SaaS founder tracking competitors** | `topicPage` set to your category, sorted by most recent launch | New products in your space, their tagline, positioning and traction |
| **Launch-day outreach and partnerships** (newsletters, podcasts, directories) | Yesterday's daily board, `maxItems: 20` | Makers who just shipped, with their profile links |
| **Market researchers and content creators** | Monthly boards over a date range, `maxItems: 0` | Every featured launch per month: topics, upvotes, ranks |
| **AI agents (via Apify MCP)** | "Find this week's top AI launches on Product Hunt and their contact emails" | Structured JSON your agent can act on |

### Example output

One row from a run on Apify for the daily board of 2026-10-20. The makers list is shortened (that row had nine makers), and `description`, `thumbnail` and the empty `socials` keys are left out here for space.

```json
{
  "name": "Composio Instant",
  "tagline": "The easiest way for AI agents to pay for their own tools",
  "productHuntUrl": "https://www.producthunt.com/products/composio",
  "website": "https://composio.dev",
  "launchDate": "2026-10-20",
  "rank": 2,
  "upvotes": 325,
  "commentCount": 46,
  "topics": ["Developer Tools", "Artificial Intelligence", "SDK"],
  "makers": [{ "name": "Sushant Hiray", "profileUrl": "https://www.producthunt.com/@sushant_hiray" }],
  "hunter": null,
  "emails": ["support@composio.dev"],
  "socials": {"x": "https://x.com/composio", "linkedin": "https://www.linkedin.com/company/composiohq/", "github": "https://github.com/composiohq/composio/"},
  "audience": "developers",
  "postId": "1265727",
  "boardKey": "2026-10-20"
}
```

### Quick start

1. Click **Try for free**. The prefilled input scrapes yesterday's daily board, 5 launches, with contacts on.
2. Change `period` (daily, weekly or monthly), the dates, `maxItems` (0 = the whole board), or a `topic` filter. Or paste product URLs, or set a topic page.
3. Download CSV, Excel or JSON, or connect Apify **Schedules** and an integration (Google Sheets, Make, Zapier, n8n, webhooks) for a hands-off daily feed.

### Why this one

- **Contacts at one flat price, only when found.** Emails plus X, LinkedIn and GitHub links from the product's own site for $2 per 1,000, charged only for launches where at least one was found. Some other Product Hunt scrapers charge per email found.
- **Real-browser extraction.** It reads Product Hunt's own page data through a real Chrome window, so it keeps working when Cloudflare blocks plain HTTP scrapers.
- **You only pay for rows you get.** No start fee. A launch is charged when its row is saved, and contacts only when the crawl found at least one email or social link.

### Input modes

The Actor picks one mode per run:

1. **Product URLs** (`productUrls`): when the list is not empty. Accepts `https://www.producthunt.com/products/<slug>` (returns the product's latest launch), `/products/<slug>/launches/<launch-slug>` and `/posts/<slug>` (return that launch). Duplicates are dropped.
2. **Topic page** (`topicPage`): when set and there are no product URLs. A slug such as `developer-tools` or a `/topics/<slug>` URL. The Actor pages through the products listed on that topic, sorted by `topicOrder` (`most_recent_launch` or `highest_rated`), and returns each product with its latest launch.
3. **Leaderboard** (default): the daily, weekly or monthly board for `startDate` to `endDate`, or the latest finished board when both dates are empty. Every page of the board is read. Product Hunt's featured daily board is usually 30 to 50 launches (2026-10-20 had 33). Set `includeNonFeatured: true` to get every launch posted in that period, featured or not; a single day can have more than 1,000.

In every mode `maxItems` caps the saved rows (default 100, `0` = no limit), rows are deduplicated by Product Hunt post id, and `topic` keeps only launches tagged with that topic slug or name.

For product URL and topic page rows, `rank` and `boardKey` refer to the daily board of that launch's day. `rank` is `null` when the launch was not ranked.

### Run it

```json
{
  "period": "daily",
  "startDate": "2026-10-20",
  "endDate": "2026-10-20",
  "maxItems": 0,
  "enrichContacts": true,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

```json
{
  "productUrls": [
    "https://www.producthunt.com/products/composio",
    "https://www.producthunt.com/products/exa-ai"
  ],
  "enrichContacts": true
}
```

```json
{ "topicPage": "developer-tools", "topicOrder": "most_recent_launch", "maxItems": 50 }
```

`startDate` and `endDate` are inclusive `YYYY-MM-DD` dates in America/Los_Angeles, Product Hunt's time zone, so "yesterday" is a finished board rather than one still collecting votes. Weekly boards use the ISO week, so the week of 2026-10-19 is `/leaderboard/weekly/2026/43`.

Proxy tiers are tried in order: the Apify datacenter proxy you selected (the account's default groups when none are picked), then a direct connection, then Apify residential proxy if `residentialFallback` is true. A tier the account does not have is skipped with an info line in the log. Leave `residentialFallback` false unless runs are failing on the Cloudflare check, because residential traffic is billed by the gigabyte.

To run it locally, install the [Apify CLI](https://docs.apify.com/cli/) and Google Chrome, then `pip install -r requirements.txt` and `apify run`. Headless Chrome and plain HTTP clients both stop on Product Hunt's Cloudflare check, so the Actor starts a headed Chrome and attaches to it over the DevTools protocol.

### Output

One launch is one dataset item. Fields that Product Hunt did not publish are JSON `null`. The Actor does not invent a hunter, an email, or a rank. `emails` is `null` when the website was not crawled. It is an empty list when the crawl finished and found no address on that site's domain. `hunter` is always `null`, because the public pages this Actor reads do not name a hunter.

`postId` is the Product Hunt post id, and a restarted run skips ids already in the dataset. `boardKey` is `2026-10-20` for a day, `2026-W43` for an ISO week, or `2026-10` for a month.

Contact enrichment loads the website homepage, `/contact`, and `/about`. An email is kept when its domain is the site that was crawled. Addresses on other domains, including sample addresses in documentation, are left out. Social links are the first profile URL found for X, LinkedIn, GitHub, Facebook, and Instagram. The audience tag is a keyword match over the topics, tagline, description, and page text. The labels are `developers`, `designers`, `marketers`, and `founders`. No language model is used. If none of the keywords appear, `audience` is `null`.

### How much does it cost to scrape Product Hunt?

The Actor uses pay per event:

| Event | Price | When it is charged |
| --- | --- | --- |
| `product` | $0.0015 | Once for each launch saved to the dataset |
| `product-enriched` | $0.002 | Once per launch, only when the website crawl found at least one email or social link (X, LinkedIn, GitHub, Facebook, Instagram) |

A run that saves 100 launches, all with contacts found, costs at most 100 × $0.0015 + 100 × $0.002 = $0.35. The daily board for 2026-10-20 had 33 launches and 27 of them had an email or a social link, so with contacts on it costs 33 × $0.0015 + 27 × $0.002 = about $0.10 (about $3.14 per 1,000 launches), or about $0.05 with `enrichContacts` off. With `includeNonFeatured` a single day can exceed 1,000 launches, so set `maxItems` to cap the cost. A launch with no website, a website that does not answer, or a crawl that finds no email and no social link is charged the `product` event only. The audience tag on its own does not trigger the contacts charge. Platform usage for the run is included in these prices.

If you set a maximum charge on the run, the Actor stops after the last row that still fits. It exits without an error, and the rows already saved stay in the dataset.

### FAQ

**Does this need a Product Hunt account?**
No. The run reads public leaderboard and product pages.

**What if Product Hunt changes the page?**
The run fails with a message that names the missing field. It does not save an empty dataset and report success. The one exception is a topic filter that matches nothing. That run succeeds and the log says the filter matched nothing.

**Why do some runs hit a Cloudflare check?**
Product Hunt sometimes puts a Turnstile check in front of the leaderboard. The Actor opens a real Chrome window and clicks that check. If a tier stays blocked it moves to the next tier, and if every tier is blocked the run fails and names the URL. Turn `residentialFallback` on only after runs start failing.

**Why is `hunter` always null?**
The public pages this Actor reads do not name the hunter, and the Actor does not guess.

**Does it get the whole board?**
Yes. Every page of the leaderboard is read, up to `maxItems` (0 = no limit). Turn on `includeNonFeatured` for launches Product Hunt did not feature.

**How current are the upvote counts?**
They are the counts on the page at request time. They are not a frozen snapshot from launch morning.

### Changelog

- **0.1.10 (2026-10-22):** The contacts event (`product-enriched`) now costs $0.002 instead of $0.004 and is charged only when the website crawl finds at least one email or social link.
- **0.1.9 (2026-10-21):** Full leaderboards: every page of daily, weekly and monthly boards instead of the first ~17 launches. New `includeNonFeatured` option. New input modes: `productUrls` and `topicPage` (with `topicOrder`). `maxItems` now defaults to 100 and accepts 0 for no limit. Rows are deduplicated by post id.
- **0.1.7 (2026-10-21):** First public release: daily, weekly and monthly leaderboards (first page), maker profiles, website emails, X / LinkedIn / GitHub links and an audience tag.

Found a bug or a page that does not parse? Open an issue on the Actor's Issues tab.

### Public data

The Actor collects information Product Hunt and the product websites show to anyone without an account. It does not bypass a login, and it does not collect data from private profiles. You are responsible for how you store and email the people behind these launches, including any rules those sites publish about automated access. This note is not legal advice.

# Actor input Schema

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

Leaderboard to read (daily, weekly or monthly). Used when no product URLs or topic page are given.

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

First board date, inclusive, as YYYY-MM-DD in America/Los_Angeles. Omit for the most recent complete board.

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

Last board date, inclusive, as YYYY-MM-DD in America/Los_Angeles. Omit to use the start date.

## `includeNonFeatured` (type: `boolean`):

Off: the featured leaderboard that Product Hunt shows by default. On: every launch posted on that day, week or month, including ones that were not featured. Non-featured launches can number in the hundreds per day, so set Max items.

## `topic` (type: `string`):

Keep only launches tagged with this topic slug or name (case-insensitive), for example developer-tools or Artificial Intelligence. Works with every mode. To list a topic's products instead, use Topic page.

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

Maximum number of launches to save. 0 means no limit: the whole board (a featured daily board is usually 30-50 launches; with non-featured launches included it can be over 1,000). Each saved launch is one charged result.

## `enrichContacts` (type: `boolean`):

Fetch each product website for emails, social links, and an audience tag.

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

Scrape these products directly instead of a leaderboard. Accepts https://www.producthunt.com/products/<slug>, /products/<slug>/launches/<launch-slug> and /posts/<slug>. A product URL returns its latest launch; a launch or post URL returns that launch.

## `topicPage` (type: `string`):

Scrape the products listed on a Product Hunt topic page, for example developer-tools or https://www.producthunt.com/topics/developer-tools. Each product is returned with its latest launch. Ignored when Product URLs are given.

## `topicOrder` (type: `string`):

Order of products on the topic page.

## `residentialFallback` (type: `boolean`):

If the datacenter proxy stays on the Cloudflare challenge, retry through the residential proxy.

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

Apify proxy used for Product Hunt. A run without a proxy token connects directly.

## Actor input object example

```json
{
  "period": "daily",
  "includeNonFeatured": false,
  "maxItems": 5,
  "enrichContacts": true,
  "topicOrder": "most_recent_launch",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

# 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",
    "maxItems": 5,
    "enrichContacts": true,
    "residentialFallback": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("weighty_nimbleness/product-hunt-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",
    "maxItems": 5,
    "enrichContacts": True,
    "residentialFallback": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("weighty_nimbleness/product-hunt-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",
  "maxItems": 5,
  "enrichContacts": true,
  "residentialFallback": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call weighty_nimbleness/product-hunt-launches --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,weighty_nimbleness/product-hunt-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/HaznCYZH1jQ7tChc4/builds/Xrj7NP275eCqSzPt2/openapi.json