# Product Hunt Scraper (with Emails) (`parsebird/product-hunt-scraper`) Actor

Scrape Product Hunt launches, leaderboards, categories, and topics. Extract product names, taglines, upvotes, ranks, makers, reviews, comments, and emails. Export as JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/product-hunt-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 product scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

Extract Product Hunt launches, leaderboard rankings, and product data from daily, weekly, monthly, yearly, category, and topic pages — including upvotes, comments, reviews, makers, built-with tools, launch history, and optional website email enrichment.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Scrape any Product Hunt leaderboard or category page — get product names, taglines, upvotes, ranks, maker profiles, reviews, comments, launch history, and website emails in structured rows ready for lead generation, market research, or competitor monitoring.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

Product Hunt Scraper (parsebird/product-hunt-scraper) extracts Product Hunt launches and product data. Call via ApifyClient: client.actor("parsebird/product-hunt-scraper").call(run\_input={"maxNbItemsToScrape": 25}). Inputs: maxNbItemsToScrape (int, 0=all), shouldIncludePromotedListings (bool), shouldScrapeOnlyFeaturedLaunches (bool), shouldScrapeListingDetails (bool — adds comments, reviews, built-with, launches), shouldScrapeWebsite (bool — fetches external website + emails), startDate (YYYY-MM-DD), endDate (YYYY-MM-DD), startWeek (YYYY-WW), endWeek (YYYY-WW), startMonth (YYYY-MM), endMonth (YYYY-MM), startYear (int), endYear (int), categorySlugs (string\[]), topicSlugs (string\[]), productHuntPageUrls (string\[]), proxyConfiguration (object). Output fields: isPromoted, name, url, tagline, categories, followers, upvotesCount, commentsCount, reviewsCount, launchesCount, dayRank, weekRank, monthRank, yearRank, launchDate, description, links, xAccountHandle, imageUrls, videoUrls, tags, team, builtWith, launches, comments, reviews, website (url, title, description, emails, rawText). Leave all target sections empty for today's California-time daily leaderboard. Get API token: https://console.apify.com/account#/integrations. Pricing: $0.50/1,000 products (standard), $0.40/1,000 (Gold). Listing details: $1.00/1,000 (standard), $0.80/1,000 (Gold). Email enrichment: $2.00/1,000 (standard), $1.60/1,000 (Gold).

````

### What does Product Hunt Scraper do?

Product Hunt Scraper extracts structured product data from [Product Hunt](https://www.producthunt.com) leaderboards, categories, and topics at scale — no API key or account required.

- 🗓️ **Daily, weekly, monthly, and yearly leaderboards** — Scrape any Product Hunt leaderboard page with date ranges
- 🏷️ **Category and topic pages** — Extract products from any Product Hunt category or topic by slug
- 🔗 **Direct URL support** — Paste leaderboard, category, or topic page URLs directly
- 📊 **Rankings and engagement** — Get day/week/month/year ranks, upvotes, comments, and follower counts
- 💬 **Listing details enrichment** — One toggle to add comments, reviews, built-with tools, and launch history per product
- 🌐 **Website enrichment with emails** — Three-pass email discovery: fetches main page, contact/about pages, and deep links to find public email addresses
- ⚡ **Defaults to today** — Leave all fields empty and the actor scrapes today's California-time daily leaderboard automatically
- 📦 **Export anywhere** — Download as JSON, CSV, Excel, or HTML directly from the Apify platform

### What data can you extract from Product Hunt?

Each product row includes core Product Hunt data with optional enrichments. Missing scalars are `null` and missing lists are `[]`.

| Data Field | Type | Description |
|------------|------|-------------|
| **isPromoted** | boolean | `true` for sponsored Product Hunt placements, `false` for organic |
| **name** | string | Product name from Product Hunt |
| **url** | string | Product Hunt product URL |
| **tagline** | string | One-line product pitch |
| **description** | string | Full product description |
| **categories** | string[] | Product Hunt categories/topics for the product |
| **upvotesCount** | number | Total upvote count |
| **followers** | number | Product follower count |
| **commentsCount** | number | Total comment count |
| **reviewsCount** | number | Total review count |
| **launchesCount** | number | Number of Product Hunt launches |
| **dayRank, weekRank, monthRank, yearRank** | number | Leaderboard rankings |
| **launchDate** | string | ISO YYYY-MM-DD launch date |
| **links** | string[] | External company links from Product Hunt |
| **xAccountHandle** | string | X (Twitter) account handle |
| **imageUrls** | string[] | Product Hunt gallery images |
| **videoUrls** | string[] | Product Hunt video links |
| **team** | array | Maker/team member objects with name, username, avatar |
| **builtWith** | array | Built-with product objects (with listing details enrichment) |
| **launches** | array | Launch history with ranks, dates, upvotes (with listing details enrichment) |
| **comments** | array | Comment objects with user, text, upvotes (with listing details enrichment) |
| **reviews** | array | Review objects with user, rating, text (with listing details enrichment) |
| **website** | object | External website with url, title, description, emails, rawText (with website enrichment) |

### How to scrape Product Hunt

1. **Open the Actor** — Go to [Product Hunt Scraper](https://apify.com/parsebird/product-hunt-scraper) on Apify Console
2. **Choose your target** — Pick one target section: daily dates, weekly, monthly, yearly, category slugs, topic slugs, or page URLs. Leave all empty for today's leaderboard.
3. **Set your limit** — Enter a number in "Maximum items across the whole run" (prefilled to 25 for a starter run)
4. **Toggle enrichments** — Enable "Listing details" for comments, reviews, built-with, and launches. Enable "Website enrichment" for email extraction.
5. **Click Start** — The Actor scrapes Product Hunt pages and emits one row per product to your dataset
6. **Download your data** — Export results as JSON, CSV, Excel, or HTML from the dataset tab

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| maxNbItemsToScrape | integer | No | 0 (all) | Cap across the whole run. Prefilled to 25. |
| shouldIncludePromotedListings | boolean | No | false | Include sponsored Product Hunt placements |
| shouldScrapeOnlyFeaturedLaunches | boolean | No | false | Keep only featured launches |
| shouldScrapeListingDetails | boolean | No | false | Add comments, reviews, built-with, launches |
| shouldScrapeWebsite | boolean | No | false | Fetch external website + emails |
| startDate / endDate | string | No | — | Daily pages in YYYY-MM-DD format |
| startWeek / endWeek | string | No | — | Weekly pages in YYYY-WW format |
| startMonth / endMonth | string | No | — | Monthly pages in YYYY-MM format |
| startYear / endYear | integer | No | — | Yearly pages |
| categorySlugs | string[] | No | [] | Product Hunt category slugs |
| topicSlugs | string[] | No | [] | Product Hunt topic slugs |
| productHuntPageUrls | string[] | No | [] | Direct leaderboard/category/topic URLs |
| proxyConfiguration | object | No | Datacenter | Proxy settings (datacenter by default) |

### Output example

This example shows a product extracted from the daily leaderboard with all enrichments enabled:

```json
{
  "isPromoted": false,
  "thumbnailUrl": "https://ph-files.imgix.net/4a7fea51-7b89-4347-9455-8423058ba07a.png?auto=compress&codec=mozjpeg&cs=strip&auto=format&w=64&h=64&fit=crop&frame=1",
  "name": "Mina Meeting Assistant",
  "url": "https://www.producthunt.com/products/mina-meeting-assistant",
  "tagline": "Your AI Teammate now responds and executes during your calls",
  "categories": ["Productivity", "Artificial Intelligence", "No-Code"],
  "followers": 1629,
  "commentsCount": 138,
  "reviewsCount": 5,
  "launchesCount": 1,
  "dayRank": 1,
  "weekRank": 8,
  "monthRank": 16,
  "yearRank": null,
  "launchDate": "2026-06-01",
  "description": "Mina is an AI meeting assistant that actively participates in meetings, responds in real time, pulls context from your tools, and helps move work forward while the conversation is still happening.",
  "upvotesCount": 502,
  "links": ["https://getmina.ai"],
  "xAccountHandle": "@heyminaai",
  "imageUrls": ["https://ph-files.imgix.net/4a7fea51-7b89-4347-9455-8423058ba07a.png?auto=format", "..."],
  "videoUrls": [],
  "tags": ["Productivity", "Artificial Intelligence", "No-Code"],
  "team": [],
  "builtWith": [],
  "launches": [],
  "comments": [],
  "reviews": [],
  "website": {
    "url": "https://getmina.ai",
    "title": "Mina - AI Meeting Assistant | Talks, Listens & Works for You",
    "description": "Mina, your AI Meeting Assistant - listens, speaks, follows directions & executes tasks live to make every meeting more productive.",
    "emails": ["hello@getmina.ai"],
    "rawText": "..."
  }
}
````

Download results in **JSON, CSV, Excel, or HTML** directly from the [Apify dataset](https://docs.apify.com/platform/storage/dataset).

### Tips for scraping Product Hunt leaderboards and categories

**Pick one target section per run.** Start date, Start week, Start month, and Start year open date-based leaderboard pages. Category slugs and Topic slugs open slug pages. Product Hunt page URLs can mix supported daily, weekly, monthly, yearly, category, and topic URLs in one run. Leave every target section empty for today's California-time daily leaderboard, or fill only one target section.

**Product Hunt shows ~20 products per leaderboard page.** Daily leaderboard pages include approximately 20 items in their server-rendered payload (typically 17 organic + 3 promoted). If you need more than 20 products, use date ranges to scrape multiple days, or enable promoted listings.

**Scrape a single past leaderboard day in depth:** Set Start date to `2026-03-20`, Maximum items to `3`, and enable both enrichment toggles. This is the quickest way to inspect one historical Product Hunt daily leaderboard with full product details.

**Scrape a Product Hunt category:** Set Category slugs to `["ai-code-editors"]` and Maximum items to `20`. Category pages return products sorted by relevance on Product Hunt.

**Scrape multiple Product Hunt pages in one run:** Set Product Hunt page URLs to `["https://www.producthunt.com/leaderboard/daily/2026/5/1/all", "https://www.producthunt.com/topics/developer-tools"]` and Maximum items to `25`. The actor scrapes each supported page sequentially.

**First run:** Leave every target section empty, set Maximum items to `5`, and leave enrichments off. This returns today's top Product Hunt launches in seconds with minimal cost.

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

Product Hunt Scraper uses pay-per-event pricing — you only pay for products delivered, not compute time.

| Event | Free / Silver / Bronze | Gold |
|-------|----------------------|------|
| Scraped product | $0.50 / 1,000 | $0.40 / 1,000 |
| Listing details (add-on) | $1.00 / 1,000 | $0.80 / 1,000 |
| Email enrichment (add-on) | $2.00 / 1,000 | $1.60 / 1,000 |

- **Scraped product** — Charged per product row saved to your dataset.
- **Listing details** — Charged when the listing details toggle is enabled (adds comments, reviews, built-with, launches).
- **Email enrichment** — Charged only when website enrichment finds at least one public email address for a saved row. If no emails are found, no email enrichment charge applies.

**Example:** Scraping 1,000 Product Hunt products from daily leaderboards costs $0.50. Adding listing details costs an additional $1.00. Adding website enrichment and finding emails on 200 of those products adds $0.40 for email enrichment, totaling $1.90.

New users get a [free trial](https://apify.com/pricing) with $5 of platform credits to test any Actor.

See the [Pricing tab](https://apify.com/parsebird/product-hunt-scraper/pricing) for current rates.

### Programmatic API usage

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "startDate": "2026-06-01",
    "maxNbItemsToScrape": 25,
    "shouldScrapeListingDetails": True,
    "shouldScrapeWebsite": True,
}

run = client.actor("parsebird/product-hunt-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['dayRank']}. {item['name']} — {item['upvotesCount']} upvotes")
```

#### JavaScript

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "<YOUR_API_TOKEN>" });

const input = {
    startDate: "2026-06-01",
    maxNbItemsToScrape: 25,
    shouldScrapeListingDetails: true,
    shouldScrapeWebsite: true,
};

const run = await client.actor("parsebird/product-hunt-scraper").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

items.forEach((item) => {
    console.log(`${item.dayRank}. ${item.name} — ${item.upvotesCount} upvotes`);
});
```

Get your API token at [Apify Console → Integrations](https://console.apify.com/account#/integrations).

Use [Apify scheduling](https://docs.apify.com/platform/schedules) to run daily, weekly, or at any interval. Combine with [integrations](https://apify.com/integrations) to push results to Google Sheets, Slack, webhooks, or your database.

### Is it legal to scrape Product Hunt?

Product Hunt Scraper accesses **publicly available product data** from Product Hunt's leaderboard, category, and topic pages. All information extracted is visible to any visitor of producthunt.com without authentication.

This Actor does not access private accounts, bypass authentication, or collect non-public personal data. It processes only the same public product launch data available to any browser visitor.

As with any data collection tool, users should review [Product Hunt's terms of service](https://www.producthunt.com/tos) and ensure their specific use case complies with applicable regulations. For more context on web scraping legality, see [Apify's guide on web scraping and the law](https://blog.apify.com/is-web-scraping-legal/).

### Related Actors

Explore more ParseBird data extraction tools:

- [Pappers.fr Company Scraper](https://apify.com/parsebird/pappers-scraper) — Extract French company data with SIREN, directors, and legal forms
- [Fotocasa Scraper](https://apify.com/parsebird/fotocasa-scraper) — Scrape Spanish real estate listings from Fotocasa.es
- [HTTP Request Actor](https://apify.com/parsebird/http-request-actor) — Send custom HTTP requests with full control over headers, method, and body
- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — Remove duplicate records from any Apify dataset
- [Data Cleaner](https://apify.com/parsebird/data-cleaner) — Clean, transform, and validate dataset records

### FAQ

**What Product Hunt pages can I scrape?**
You can scrape daily, weekly, monthly, and yearly leaderboard pages, category pages, and topic pages. Product URLs, post URLs, search pages, and the homepage are not supported — only pages that list multiple products.

**Do I need a Product Hunt API key?**
No. Product Hunt Scraper extracts data from Product Hunt's public web pages. No API key, developer token, or Product Hunt account is required.

**How fresh is the data?**
Every run scrapes Product Hunt live. Results reflect the page at run time — upvotes, ranks, and comments are current as of the moment the actor runs.

**Can I scrape historical Product Hunt leaderboards?**
Yes. Product Hunt keeps historical leaderboard pages. Set Start date to any past date (e.g. `2024-01-15`) to scrape that day's leaderboard. Use date ranges for multiple days.

**What is the listing details enrichment?**
When enabled, the actor fetches additional data from each product's Product Hunt listing page — including comments, reviews, built-with tools, and launch history. This is charged as a separate "detail-scraped" event.

**What is the email enrichment add-on?**
When you enable "Website enrichment", the actor fetches each product's external website using a three-pass strategy (main page → contact pages → deep links) to discover public email addresses. The email enrichment event is charged only for rows where at least one email is found.

**Why did I get fewer items than my maxItems setting?**
Product Hunt serves approximately 20 items per leaderboard page in the server-rendered payload. If you set maxItems to 25 but only one daily page is being scraped, you may get up to 20 items (or fewer if promoted listings are excluded). Use date ranges or multiple pages to get more total items.

**Can I schedule recurring Product Hunt scrapes?**
Yes. Use [Apify scheduling](https://docs.apify.com/platform/schedules) to run daily, weekly, or at any custom interval. Combine with [integrations](https://apify.com/integrations) to push results to Google Sheets, Slack, webhooks, or your database.

**How many products can I scrape per run?**
Set maxNbItemsToScrape to 0 for unlimited results. Each leaderboard page provides up to ~20 products. Use date ranges to scrape multiple days and get hundreds or thousands of products in one run.

**What format are the results in?**
Results are available as JSON, CSV, Excel, or HTML directly from the Apify dataset tab. You can also access them programmatically via the [Apify API](https://docs.apify.com/api/v2).

# Actor input Schema

## `maxNbItemsToScrape` (type: `integer`):

Optional cap applied across the whole Product Hunt run, even when the input resolves to multiple pages. Category and topic runs keep following Product Hunt pagination until this cap is satisfied or no more pages exist. Set to 0 to request all available items.

## `shouldIncludePromotedListings` (type: `boolean`):

Include sponsored Product Hunt placements from the same page. Off by default so runs stay organic unless you opt in.

## `shouldScrapeOnlyFeaturedLaunches` (type: `boolean`):

Keep only Product Hunt launches from the featured feed for the selected target. Off by default so runs include the full eligible leaderboard, category, or topic page.

## `shouldScrapeListingDetails` (type: `boolean`):

Enrich each product with comments, reviews, built-with tools, and launch history from its Product Hunt listing page. Charged as a detail-scraped event.

## `shouldScrapeWebsite` (type: `boolean`):

Fetch each product's external website and extract title, description, visible text, and public email addresses. Uses a three-pass strategy (main page, contact pages, deep links) for thorough email discovery. Charged as an email-enrichment event only when at least one email is found.

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

Daily pages only. Enter one Product Hunt daily date in YYYY-MM-DD format. Add End date only when you want an inclusive daily range.

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

Daily pages only. Optional inclusive end date in YYYY-MM-DD format. Leave blank to scrape one day.

## `startWeek` (type: `string`):

Weekly pages only. Enter one Product Hunt week in YYYY-WW format such as 2026-25. Add End week only when you want an inclusive weekly range.

## `endWeek` (type: `string`):

Weekly pages only. Optional inclusive end week in YYYY-WW format. Leave blank to scrape one week.

## `startMonth` (type: `string`):

Monthly pages only. Enter one Product Hunt month in YYYY-MM format such as 2026-06. Add End month only when you want an inclusive monthly range.

## `endMonth` (type: `string`):

Monthly pages only. Optional inclusive end month in YYYY-MM format. Leave blank to scrape one month.

## `startYear` (type: `integer`):

Yearly pages only. Enter one Product Hunt year such as 2026. Add End year only when you want an inclusive yearly range.

## `endYear` (type: `integer`):

Yearly pages only. Optional inclusive end year. Leave blank to scrape one year.

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

Category pages only. Add one Product Hunt category slug per row, for example ai-code-editors. Category pages do not support date ranges.

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

Topic pages only. Add one Product Hunt topic slug per row, for example developer-tools or open-source. The legacy alias opensource is also accepted.

## `productHuntPageUrls` (type: `array`):

Add daily, weekly, monthly, yearly, category, or topic page URLs. Product, post, search, home, and other Product Hunt URLs are rejected before scraping.

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

Proxy settings for accessing Product Hunt. Datacenter proxies work reliably for most runs. Switch to residential if you encounter blocks.

## Actor input object example

```json
{
  "maxNbItemsToScrape": 25,
  "shouldIncludePromotedListings": false,
  "shouldScrapeOnlyFeaturedLaunches": false,
  "shouldScrapeListingDetails": false,
  "shouldScrapeWebsite": false,
  "categorySlugs": [],
  "topicSlugs": [],
  "productHuntPageUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "maxNbItemsToScrape": 25,
    "shouldIncludePromotedListings": false,
    "shouldScrapeOnlyFeaturedLaunches": false,
    "shouldScrapeListingDetails": false,
    "shouldScrapeWebsite": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "SHADER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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 = {
    "maxNbItemsToScrape": 25,
    "shouldIncludePromotedListings": False,
    "shouldScrapeOnlyFeaturedLaunches": False,
    "shouldScrapeListingDetails": False,
    "shouldScrapeWebsite": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["SHADER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/product-hunt-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxNbItemsToScrape": 25,
  "shouldIncludePromotedListings": false,
  "shouldScrapeOnlyFeaturedLaunches": false,
  "shouldScrapeListingDetails": false,
  "shouldScrapeWebsite": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "SHADER"
    ]
  }
}' |
apify call parsebird/product-hunt-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parsebird/product-hunt-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt Scraper (with Emails)",
        "description": "Scrape Product Hunt launches, leaderboards, categories, and topics. Extract product names, taglines, upvotes, ranks, makers, reviews, comments, and emails. Export as JSON, CSV, Excel.",
        "version": "1.2",
        "x-build-id": "7IWzakVdk5anTDeEo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~product-hunt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-product-hunt-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parsebird~product-hunt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-product-hunt-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parsebird~product-hunt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-product-hunt-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxNbItemsToScrape": {
                        "title": "Maximum items across the whole run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional cap applied across the whole Product Hunt run, even when the input resolves to multiple pages. Category and topic runs keep following Product Hunt pagination until this cap is satisfied or no more pages exist. Set to 0 to request all available items.",
                        "default": 0
                    },
                    "shouldIncludePromotedListings": {
                        "title": "Include promoted listings?",
                        "type": "boolean",
                        "description": "Include sponsored Product Hunt placements from the same page. Off by default so runs stay organic unless you opt in.",
                        "default": false
                    },
                    "shouldScrapeOnlyFeaturedLaunches": {
                        "title": "Featured launches only?",
                        "type": "boolean",
                        "description": "Keep only Product Hunt launches from the featured feed for the selected target. Off by default so runs include the full eligible leaderboard, category, or topic page.",
                        "default": false
                    },
                    "shouldScrapeListingDetails": {
                        "title": "Scrape listing details? (comments, reviews, built-with, launches)",
                        "type": "boolean",
                        "description": "Enrich each product with comments, reviews, built-with tools, and launch history from its Product Hunt listing page. Charged as a detail-scraped event.",
                        "default": false
                    },
                    "shouldScrapeWebsite": {
                        "title": "Scrape website enrichment? (emails, title, description)",
                        "type": "boolean",
                        "description": "Fetch each product's external website and extract title, description, visible text, and public email addresses. Uses a three-pass strategy (main page, contact pages, deep links) for thorough email discovery. Charged as an email-enrichment event only when at least one email is found.",
                        "default": false
                    },
                    "startDate": {
                        "title": "Start date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Daily pages only. Enter one Product Hunt daily date in YYYY-MM-DD format. Add End date only when you want an inclusive daily range."
                    },
                    "endDate": {
                        "title": "End date (optional)",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "Daily pages only. Optional inclusive end date in YYYY-MM-DD format. Leave blank to scrape one day."
                    },
                    "startWeek": {
                        "title": "Start week",
                        "pattern": "^\\d{4}-(0[1-9]|[1-4]\\d|5[0-3])$",
                        "type": "string",
                        "description": "Weekly pages only. Enter one Product Hunt week in YYYY-WW format such as 2026-25. Add End week only when you want an inclusive weekly range."
                    },
                    "endWeek": {
                        "title": "End week (optional)",
                        "pattern": "^\\d{4}-(0[1-9]|[1-4]\\d|5[0-3])$",
                        "type": "string",
                        "description": "Weekly pages only. Optional inclusive end week in YYYY-WW format. Leave blank to scrape one week."
                    },
                    "startMonth": {
                        "title": "Start month",
                        "pattern": "^\\d{4}-(0[1-9]|1[0-2])$",
                        "type": "string",
                        "description": "Monthly pages only. Enter one Product Hunt month in YYYY-MM format such as 2026-06. Add End month only when you want an inclusive monthly range."
                    },
                    "endMonth": {
                        "title": "End month (optional)",
                        "pattern": "^\\d{4}-(0[1-9]|1[0-2])$",
                        "type": "string",
                        "description": "Monthly pages only. Optional inclusive end month in YYYY-MM format. Leave blank to scrape one month."
                    },
                    "startYear": {
                        "title": "Start year",
                        "minimum": 2013,
                        "maximum": 9999,
                        "type": "integer",
                        "description": "Yearly pages only. Enter one Product Hunt year such as 2026. Add End year only when you want an inclusive yearly range."
                    },
                    "endYear": {
                        "title": "End year (optional)",
                        "minimum": 2013,
                        "maximum": 9999,
                        "type": "integer",
                        "description": "Yearly pages only. Optional inclusive end year. Leave blank to scrape one year."
                    },
                    "categorySlugs": {
                        "title": "Category slugs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Category pages only. Add one Product Hunt category slug per row, for example ai-code-editors. Category pages do not support date ranges.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$"
                        },
                        "default": []
                    },
                    "topicSlugs": {
                        "title": "Topic slugs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Topic pages only. Add one Product Hunt topic slug per row, for example developer-tools or open-source. The legacy alias opensource is also accepted.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$"
                        },
                        "default": []
                    },
                    "productHuntPageUrls": {
                        "title": "Product Hunt page URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Add daily, weekly, monthly, yearly, category, or topic page URLs. Product, post, search, home, and other Product Hunt URLs are rejected before scraping.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        },
                        "default": []
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for accessing Product Hunt. Datacenter proxies work reliably for most runs. Switch to residential if you encounter blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "SHADER"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```