# Product Hunt Scraper with Founders & Emails (`fatihtahta/product-hunt-scraper-fast-reliable-4-1k`) Actor

Extract structured Product Hunt launches with founders, emails, votes, comments, topics, websites, social media and more. Built for enterprise-grade startup intelligence, founder discovery, market analysis, and automated lead enrichment or analytics pipelines.

- **URL**: https://apify.com/fatihtahta/product-hunt-scraper-fast-reliable-4-1k.md
- **Developed by:** [Fatih Tahta](https://apify.com/fatihtahta) (community)
- **Categories:** Lead generation, Agents, Automation
- **Stats:** 494 total users, 39 monthly users, 64.2% runs succeeded, 21 bookmarks
- **User rating**: 4.24 out of 5 stars

## Pricing

from $0.50 / 1,000 products

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?

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 with Founders & Emails

**Slug:** `fatihtahta/product-hunt-scraper-fast-reliable-4-1k`

### Overview

Product Hunt Scraper with Founders & Emails collects structured Product Hunt launch records, including product names, taglines, launch URLs, vote and comment counts, rankings, topics, websites, media, launch history, maker profiles, social links, and optional founder email data. [Product Hunt](https://www.producthunt.com) is a public discovery platform for new products, startups, and maker-led launches, making its launch data useful for market intelligence, trend analysis, founder discovery, and competitive monitoring. The actor produces repeatable JSON output that can be used in automation workflows, dashboards, enrichment pipelines, and operational reporting. It is designed for dependable recurring data acquisition from selected dates or Product Hunt leaderboard URLs while keeping output structured and consistent across runs. Users can choose the scope, enrichment depth, comment collection, and maximum number of product records to match validation, monitoring, or production data workflows.

### Why Use This Actor

- **Market research and analytics:** build structured extraction workflows for launch activity, topic movement, voting patterns, maker participation, and category-level market intelligence.
- **Product and content teams:** discover emerging products, launch narratives, maker profiles, and discussion context for editorial planning, product research, and competitive briefings.
- **Developers and data engineering pipelines:** feed normalized Product Hunt records into downstream systems, warehouses, search indexes, internal tools, and monitoring workflows.
- **Lead generation and enrichment teams:** create founder-oriented datasets with public maker profiles, websites, social links, and optional email enrichment for responsible outreach workflows.
- **Monitoring and competitive tracking teams:** schedule repeatable collection for daily, monthly, or custom leaderboard views and compare rankings, engagement, launches, and topic coverage over time.

### Common Use Cases

- **Market intelligence:** monitor Product Hunt launch volume, engagement, rankings, topics, and category movement across selected leaderboard views.
- **Lead generation:** build targeted prospect lists from public product launches, maker profiles, websites, and optional founder email fields.
- **Competitive monitoring:** track new launches, product positioning, social presence, and engagement signals in markets relevant to your company.
- **Catalog and directory building:** populate internal databases with structured public records for products, makers, launch metadata, and media assets.
- **Data enrichment:** add current public Product Hunt attributes to existing CRM, BI, or analytics datasets.
- **Recurring reporting:** schedule periodic runs for dashboards, alerts, trend analysis, and launch ecosystem reporting.

### Quick Start

1. Choose a Product Hunt launch `date` or provide one or more direct leaderboard `urls`.
2. Set a small `maxProducts` value for the first validation run.
3. Choose whether to include makers, comments, and founder email enrichment.
4. Review the pricing impact of product records, comments, saved founders, and email enrichment before scaling.
5. Run the actor in Apify Console.
6. Inspect the first dataset records to confirm the shape matches your use case.
7. Increase coverage, add targeted leaderboard URLs, or schedule the actor once the output is verified.

### Input Parameters

This actor accepts a Product Hunt leaderboard date or direct leaderboard URLs, plus enrichment and collection limit options.

| Parameter | Type | Description | Default |
|---|---:|---|---:|
| `date` | string | Product Hunt launch date to collect, formatted as `YYYY-MM-DD`. Future dates are not supported. If no `date` or `urls` are provided, the actor collects the current Product Hunt day. | - |
| `scrapeOnlyFeatured` | boolean | When enabled, collects Product Hunt featured launches only. When disabled, includes the broader list of products for the selected leaderboard target. | `false` |
| `urls` | array of strings | One or more direct Product Hunt leaderboard URLs. When provided, these take priority over `date` and can be used for daily, monthly, yearly, or custom leaderboard views. | - |
| `scrapeMakers` | boolean | Includes makers associated with each Product Hunt launch, such as names, profile URLs, headlines, avatars, and available social or website links. | `true` |
| `getComments` | boolean | Collects comments associated with each product when available. This can add useful launch discussion context and may increase output volume. | `false` |
| `enrichWithEmail` | boolean | Attempts to add potential founder email addresses to maker records when enough public product and maker information is available. | `false` |
| `includeRiskyEmails` | boolean | Includes additional email matches that may be less certain. Email results are labeled by confidence where available so downstream systems can filter them later. | `true` |
| `maxProducts` | integer | Optional maximum number of product records to collect across the selected leaderboard targets. Leave it empty to collect every available product. | All available |

### Choosing Inputs

Use `date` when you need the Product Hunt launch leaderboard for a specific day, or leave it empty to collect the current Product Hunt day. Use `urls` when you already know the exact Product Hunt leaderboard pages you want to collect, such as monthly, yearly, or custom leaderboard views; direct URLs take priority over `date`.

For early validation, set `maxProducts` to a small value and inspect the dataset before increasing coverage. Leave it empty for complete collection. Products and comments are saved incrementally in batches, so long runs show usable dataset progress instead of waiting for the entire collection to finish. Enable `scrapeOnlyFeatured` when you want a more focused dataset around featured launches, and keep it disabled when discovery coverage matters more. Enable `scrapeMakers`, `getComments`, and `enrichWithEmail` only when those fields are useful for your workflow, since richer records can take longer and produce larger datasets.

Requested comments include all exposed discussion pages and reply continuations. Product Hunt's displayed comment total can include comments its public API does not expose, so it may differ from the number of saved comment rows. Maker output has up to three maker slots per product.

Failed acquisition, incomplete requested enrichment, invalid input, or a dataset/summary mismatch produces a failed run while preserving already saved records. Inspect `RUN-SUMMARY` for coverage, saved counts, and failure details. Email validation failures are reported separately from a successful search that found no matching address.

### Pricing

The live listing checked on September 13, 2026 charges $0.50–$0.75 per 1,000 default-dataset records, depending on subscription tier. Both product and comment rows use that dataset-item event. Optional founders cost $1 per 1,000 saved founders, and discovered emails cost $2 per 1,000 saved emails ($0.002 each). Confirm the current pricing in [Apify Console](https://console.apify.com/actors/tq6PGVk5IzujI7eiY/input) before starting a run.

For cost control, start with a small `maxProducts` value, verify the output, and enable `getComments` or `enrichWithEmail` only when comment collection or email discovery is required for the run. Pricing may vary by plan or actor listing configuration, so review the pricing shown in Apify Console before running large jobs.

### Example Inputs

#### Daily launch validation

```json
{
  "date": "2026-02-01",
  "scrapeOnlyFeatured": false,
  "scrapeMakers": true,
  "getComments": false,
  "enrichWithEmail": false,
  "maxProducts": 25
}
```

#### Direct leaderboard URL collection

```json
{
  "urls": [
    "https://www.producthunt.com/leaderboard/monthly/2026/2"
  ],
  "scrapeOnlyFeatured": false,
  "scrapeMakers": true,
  "getComments": true,
  "enrichWithEmail": false,
  "maxProducts": 100
}
```

#### Founder enrichment run

```json
{
  "date": "2026-02-01",
  "scrapeOnlyFeatured": true,
  "scrapeMakers": true,
  "getComments": true,
  "enrichWithEmail": true,
  "includeRiskyEmails": false,
  "maxProducts": 50
}
```

### Output

#### Output destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, and downstream APIs with minimal post-processing.

When multiple entity types or record shapes exist, this README documents each shape separately based on the provided Example Output.

#### Record envelope and stable identifiers

Each dataset item is a JSON object with a `type` field. In the provided output contract, the record type is `Product`.

The recommended idempotency key is `productUrl`, because it is the strongest stable top-level identifier available in the example output. If your downstream system also stores launch history, `launchHistory.id` can be used as a secondary launch-level identifier. For deduplication and upserts, use `productUrl` as the primary key and update the existing record when later runs return the same product with refreshed engagement, maker, or launch fields. Stable identifiers make records easier to merge, deduplicate, and sync across repeated runs.

#### Examples

##### Example: Product (`type = "Product"`)

```json
{
  "type": "Product",
  "productName": "Reavion",
  "productTagline": "Autonomous browser agents for outbound and GTM execution",
  "productUrl": "https://www.producthunt.com/posts/reavion",
  "productThumbnailUrl": "https://ph-files.imgix.net/f7a55d51-1e3c-44fd-924d-e63cf8f5d616.png",
  "votesCount": 151,
  "commentsCount": 26,
  "dailyRank": "6",
  "leaderboardPeriod": "daily",
  "leaderboardRank": 6,
  "topics": [
    "SaaS",
    "Artificial Intelligence",
    "Marketing automation"
  ],
  "websiteUrl": "https://reavion.com",
  "followersCount": 157,
  "productDescription": "Reavion is an AI-powered browser that navigates, reads, decides, and acts for you. Automate outbound and go-to-market tasks, save hours on repetitive workflows, and scale growth without extra hires. Designed for founders, marketers, and teams who want smarter, faster, reliable automation.",
  "mediaGallery": [
    "https://ph-files.imgix.net/f566765d-bdc4-40e2-bcfc-3a42e625cd82.png",
    "https://ph-files.imgix.net/d0ceb80f-4aa9-4481-b837-ca1403de923d.png",
    "https://ph-files.imgix.net/1b68bec3-1ec6-4142-a6ac-a20323a689b1.png",
    "https://ph-files.imgix.net/2cc5a575-3190-4555-99d4-fe2a4fbf92b6.png",
    "https://youtu.be/YGcSZAr7NVU"
  ],
  "launchHistory": [
    {
      "id": "1056377",
      "slug": "reavion",
      "name": "Reavion",
      "tagline": "Autonomous browser agents for outbound and GTM execution",
      "launchNumber": null,
      "scheduledAt": null,
      "createdAt": "2026-02-01T00:01:00-08:00",
      "featuredAt": "2026-02-01T00:01:00-08:00",
      "updatedAt": "2026-04-27T22:01:24-07:00",
      "dailyRank": "6",
      "weeklyRank": "51",
      "monthlyRank": "181",
      "commentsCount": 26,
      "latestScore": 151,
      "launchDayScore": 147,
      "featured": null,
      "launchState": null,
      "launchingToday": null,
      "launchedThisWeek": null,
      "badges": []
    }
  ],
  "makerName1": "Helder Perez",
  "makerUsername1": "helderperez",
  "makerHeadline1": "Founder and Software Engineer",
  "isGoldMaker1": false,
  "makerAvatarUrl1": "https://ph-avatars.imgix.net/8560339/0f0de845-59f0-4a97-97d6-f0f7eea202da.png",
  "makerProfileUrl1": "https://www.producthunt.com/@helderperez",
  "maker1twitter": "https://x.com/helderbuilds",
  "maker1linkedin": "https://www.linkedin.com/in/helderperez/",
  "maker1website": "https://www.reavion.com",
  "makerName2": null,
  "makerUsername2": null,
  "makerHeadline2": null,
  "isGoldMaker2": null,
  "makerAvatarUrl2": null,
  "makerProfileUrl2": null,
  "maker2twitter": null,
  "maker2linkedin": null,
  "maker2website": null,
  "makerName3": null,
  "makerUsername3": null,
  "makerHeadline3": null,
  "isGoldMaker3": null,
  "makerAvatarUrl3": null,
  "makerProfileUrl3": null,
  "maker3twitter": null,
  "maker3linkedin": null,
  "maker3website": null,
  "makerEmail1": "helder@reavion.com",
  "makerEmailStatus1": "verified"
}
```

### Field Reference

#### Product

**type** *(string, required)*: Record type. In this contract, the value is `Product`.

**productName** *(string, required)*: Product name.

**productTagline** *(string, optional)*: Short Product Hunt tagline.

**productUrl** *(string, required)*: Public Product Hunt product page URL and recommended idempotency key.

**productThumbnailUrl** *(string, optional)*: Product thumbnail image URL.

**votesCount** *(integer, optional)*: Number of votes shown for the product.

**commentsCount** *(integer, optional)*: Number of comments shown for the product.

**dailyRank** *(string, optional)*: Product rank for the selected daily leaderboard context.

**leaderboardPeriod** *(string, optional)*: Leaderboard period selected for this result: `daily`, `weekly`, `monthly`, or `yearly`.

**leaderboardRank** *(integer, optional)*: One-based position of the product in the selected leaderboard period. Use this field instead of `dailyRank` for weekly, monthly, and yearly runs.

**topics** *(array of strings, optional)*: Product Hunt topics associated with the launch.

**websiteUrl** *(string, optional)*: Public website URL associated with the product.

**followersCount** *(integer, optional)*: Number of Product Hunt followers shown for the product.

**productDescription** *(string, optional)*: Product description text.

**mediaGallery** *(array of strings, optional)*: Product media URLs, such as images or videos.

**launchHistory** *(array of objects, optional)*: Launch history entries associated with the product.

**launchHistory.id** *(string, optional)*: Launch-level identifier.

**launchHistory.slug** *(string, optional)*: Product Hunt launch slug.

**launchHistory.name** *(string, optional)*: Launch name.

**launchHistory.tagline** *(string, optional)*: Launch tagline.

**launchHistory.launchNumber** *(integer or null, optional)*: Launch number when available.

**launchHistory.scheduledAt** *(string or null, optional)*: Scheduled launch timestamp when available.

**launchHistory.createdAt** *(string, optional)*: Launch creation timestamp.

**launchHistory.featuredAt** *(string or null, optional)*: Featured timestamp when available.

**launchHistory.updatedAt** *(string, optional)*: Last updated timestamp shown for the launch entry.

**launchHistory.dailyRank** *(string, optional)*: Daily rank for the launch entry.

**launchHistory.weeklyRank** *(string, optional)*: Weekly rank for the launch entry.

**launchHistory.monthlyRank** *(string, optional)*: Monthly rank for the launch entry.

**launchHistory.commentsCount** *(integer, optional)*: Comment count for the launch entry.

**launchHistory.latestScore** *(integer, optional)*: Latest score shown for the launch entry.

**launchHistory.launchDayScore** *(integer, optional)*: Score shown for the launch day.

**launchHistory.featured** *(boolean or null, optional)*: Featured status when available.

**launchHistory.launchState** *(string or null, optional)*: Launch state when available.

**launchHistory.launchingToday** *(boolean or null, optional)*: Whether the product is launching today when available.

**launchHistory.launchedThisWeek** *(boolean or null, optional)*: Whether the product launched this week when available.

**launchHistory.badges** *(array, optional)*: Badge values associated with the launch entry.

**makerName1 / makerName2 / makerName3** *(string or null, optional)*: Maker names for up to three makers represented as convenience fields.

**makerUsername1 / makerUsername2 / makerUsername3** *(string or null, optional)*: Product Hunt usernames for the corresponding makers.

**makerHeadline1 / makerHeadline2 / makerHeadline3** *(string or null, optional)*: Maker profile headlines.

**isGoldMaker1 / isGoldMaker2 / isGoldMaker3** *(boolean or null, optional)*: Product Hunt Gold maker status when available.

**makerAvatarUrl1 / makerAvatarUrl2 / makerAvatarUrl3** *(string or null, optional)*: Maker avatar image URLs.

**makerProfileUrl1 / makerProfileUrl2 / makerProfileUrl3** *(string or null, optional)*: Public Product Hunt maker profile URLs.

**maker1twitter / maker2twitter / maker3twitter** *(string or null, optional)*: Public X or Twitter profile URLs for the corresponding makers.

**maker1linkedin / maker2linkedin / maker3linkedin** *(string or null, optional)*: Public LinkedIn profile URLs for the corresponding makers.

**maker1website / maker2website / maker3website** *(string or null, optional)*: Public maker website URLs.

**makerEmail1** *(string, optional)*: Email address associated with the first maker when email enrichment is enabled and a result is available.

**makerEmailStatus1** *(string, optional)*: Confidence or verification status for `makerEmail1`.

### Data Quality, Guarantees, And Handling

- **Structured records:** results are normalized into predictable JSON objects for downstream use.
- **Best-effort extraction:** fields may vary by region, session, availability, and Product Hunt interface experiments.
- **Optional fields:** null-check optional fields in downstream code, especially maker, social, email, media, and launch history attributes.
- **Deduplication:** use `productUrl` as the strongest stable top-level key available from the output; use `launchHistory.id` as a secondary launch-level key where helpful.
- **Freshness:** results reflect the publicly available data at run time.
- **Repeated runs:** use the recommended idempotency key when syncing data into warehouses, CRMs, or search indexes.

### Tips For Best Results

- Start with a small `maxProducts` value to validate the output shape before scaling up.
- Use `date` for daily launch monitoring and `urls` for specific leaderboard views.
- Use one date or a focused set of leaderboard URLs per run when you need cleaner segmentation.
- Leave `scrapeOnlyFeatured` disabled when the goal is broader launch discovery.
- Enable `getComments` only when launch discussion and engagement context are part of the analysis.
- Enable `enrichWithEmail` for founder outreach workflows, and use `includeRiskyEmails` based on your tolerance for broader versus stricter email matching.
- Schedule recurring runs for monitoring workflows and use `productUrl` for deduplication over time.

### How to Run on Apify

1. Open the actor in Apify Console.
2. Configure the available input fields for the target scope.
3. Optionally set the maximum number of outputs with `maxProducts`, or leave it empty for complete collection.
4. Click **Start** and wait for the run to finish.
5. Open the dataset and inspect the first records.
6. Download results in JSON, CSV, Excel, or other supported formats.

### Scheduling & Automation

#### Scheduling

**Automated Data Collection**

You can schedule runs to keep Product Hunt launch, maker, and enrichment datasets fresh without manual collection. Scheduled runs are useful for daily launch monitoring, recurring market intelligence, and repeatable CRM or warehouse syncs.

- Navigate to **Schedules** in Apify Console
- Create a new schedule, such as daily, weekly, or custom cron
- Configure input parameters
- Enable notifications for run completion
- Add webhooks for automated processing

#### Integration Options

- **CRM enrichment:** sync public product, maker, website, social, and email fields into account or lead records.
- **Google Sheets or Airtable:** review launch lists, founder contacts, topics, and engagement metrics in lightweight operating workflows.
- **Webhooks:** trigger validation, notification, or ingestion workflows after each completed run.
- **BI dashboards:** monitor Product Hunt launch activity, ranking movement, votes, comments, topics, and founder coverage over time.
- **Data enrichment pipelines:** append Product Hunt context to existing company, product, founder, or market intelligence datasets.
- **Slack, Discord, or email alerts:** notify teams when new launches or target leaderboard records are collected.

### Export Formats And Downstream Use

Apify datasets can be exported or consumed by downstream systems for operational reporting, analytics, enrichment, and automated ingestion.

- **JSON:** for APIs, applications, and data pipelines
- **CSV or Excel:** for spreadsheet workflows and manual review
- **API access:** for automated ingestion into internal systems
- **BI and warehouses:** for reporting, dashboards, and historical analysis

### Performance

Estimated run times:

- **Small runs (< 1,000 outputs):** ~3-5 minutes
- **Medium runs (1,000-5,000 outputs):** ~5-15 minutes
- **Large runs (5,000+ outputs):** ~15-30 minutes

Execution time varies based on filters, result volume, and how much information is returned per record. Highly filtered runs can finish faster, while broad discovery or detail-rich records with makers, comments, and email enrichment may take longer.

### Limitations

- Availability depends on what [Product Hunt](https://www.producthunt.com) publicly exposes at run time.
- Some optional fields may be missing on sparse records or records with limited public profile information.
- Very broad leaderboard collection may take longer, but completed leaderboard pages are saved incrementally throughout the run.
- Target-side changes can affect field availability, naming, or visibility.
- Regional, account, or availability differences may change visible results.
- Email enrichment is best-effort and should be reviewed before use in outreach workflows.

### Troubleshooting

- **No results returned:** check the selected `date`, direct `urls`, and whether Product Hunt has matching public leaderboard records for the target scope.
- **Fewer results than expected:** broaden the scope, raise `maxProducts`, disable `scrapeOnlyFeatured`, or verify that the selected target contains enough matching records.
- **Some fields are empty:** optional fields depend on what each product, launch, maker, or profile publicly provides.
- **Run takes longer than expected:** reduce scope, lower `maxProducts` for validation, or split broad collection into smaller runs.
- **Output changed:** compare the current output with the field reference and report a small sample if support is needed.

### FAQ

#### What data does this actor collect?

It collects public Product Hunt launch records, including product details, rankings, votes, comments count, topics, websites, media, launch history, maker profile fields, social links, and optional founder email data.

#### Can I filter by location, category, date, price, or other criteria?

The supported scope controls are `date`, direct leaderboard `urls`, `scrapeOnlyFeatured`, and `maxProducts`. The schema does not include location, price, or category filter fields.

#### Why did I receive fewer results than my limit?

`maxProducts` is an optional upper limit, not a guaranteed count. The selected date or leaderboard URL may contain fewer public records, or the enabled scope may be narrower than the limit. When omitted, the actor follows the selected leaderboards until Product Hunt reports that no pages remain.

#### Can I schedule recurring runs?

Yes. Use Apify schedules to run the actor on a daily, weekly, or custom cadence for recurring monitoring and reporting.

#### How do I avoid duplicates across runs?

Use `productUrl` as the recommended idempotency key when storing or syncing results. If you need launch-level tracking, also store `launchHistory.id` when present.

#### Can I export the data to CSV, Excel, or JSON?

Yes. Apify datasets can be downloaded in JSON, CSV, Excel, and other supported formats.

#### How does pricing work?

Pricing is based on saved outputs. Product launch and detail records are charged at approximately $2 to $1 per 100 saved launches depending on your Apify subscription tier. Comments gathered and saved to the dataset use the same tier-based rate, approximately $2 to $1 per 1,000 saved comments. Saved founder records are charged at $1 per 1,000 founders, and founder email enrichment is charged at $2 per discovered email saved to the dataset.

#### Does this actor collect private data?

The actor is intended to collect publicly available Product Hunt product, launch, maker, and related enrichment information. Users are responsible for using the data lawfully and responsibly.

#### What should I include when reporting an issue?

Include the input used, with sensitive values redacted, the run ID, expected versus actual behavior, and a small output sample if it helps illustrate the issue.

### Compliance & Ethics

#### Responsible Data Collection

This actor collects publicly available **Product Hunt launch, product, maker, and contact enrichment** information from **https://www.producthunt.com** for legitimate business purposes, including:

- **Startup ecosystem** research and market analysis
- **Founder and product discovery** for responsible business development
- **Competitive and trend monitoring** for operational reporting

This section is informational and not legal advice. Users are responsible for ensuring that their use of collected data complies with applicable laws, regulations, platform terms, and internal policies.

#### Best Practices

- Use collected data in accordance with applicable laws, regulations, and the target site's terms
- Respect individual privacy and personal information
- Use data responsibly and avoid disruptive or excessive collection
- Do not use this actor for spamming, harassment, or other harmful purposes
- Follow relevant data protection requirements where applicable, such as GDPR and CCPA

### Support

For help, use the actor page or Issues section. Include the input used with sensitive values redacted, the run ID, expected versus actual behavior, and an optional small output sample so the issue can be reviewed efficiently.

# Actor input Schema

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

Choose the Product Hunt leaderboard date to collect, such as 2025-08-30. Future dates are not supported; if no date or direct URL is provided, the actor collects today's leaderboard.

## `scrapeOnlyFeatured` (type: `boolean`):

Enable this to focus on Product Hunt's featured launches. Leave it off to include the broader list of products launched for the selected leaderboard target.

## `urls` (type: `array`):

Enter one or more Product Hunt leaderboard URLs. When URLs are provided, they take priority over the launch date; use this for targeted month, year, or custom leaderboard collection.

## `scrapeMakers` (type: `boolean`):

Enable this to include the makers associated with each Product Hunt launch. Keeping it enabled creates richer records; disabling it keeps the output more product-focused.

## `getComments` (type: `boolean`):

Enable this to collect comments associated with each product. Comment collection adds context to the dataset and may increase the run time and output volume.

## `enrichWithEmail` (type: `boolean`):

Enable email enrichment to add potential founder email addresses to maker records when enough product and maker information is available. This creates more actionable output and may make runs take longer.

## `includeRiskyEmails` (type: `boolean`):

Allow additional email matches that may be less certain. Results are labeled by confidence so you can keep broader discovery during collection and filter lower-confidence emails later.

## `maxProducts` (type: `integer`):

Optionally set the highest number of product records to collect across the selected leaderboard targets. Leave this empty for complete collection; results are saved incrementally as leaderboard pages finish.

## Actor input object example

```json
{
  "scrapeOnlyFeatured": false,
  "scrapeMakers": true,
  "getComments": false,
  "enrichWithEmail": false,
  "includeRiskyEmails": true,
  "maxProducts": 100
}
```

# 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 = {
    "maxProducts": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihtahta/product-hunt-scraper-fast-reliable-4-1k").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 = { "maxProducts": 100 }

# Run the Actor and wait for it to finish
run = client.actor("fatihtahta/product-hunt-scraper-fast-reliable-4-1k").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 '{
  "maxProducts": 100
}' |
apify call fatihtahta/product-hunt-scraper-fast-reliable-4-1k --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fatihtahta/product-hunt-scraper-fast-reliable-4-1k"
        }
    }
}
```

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/tq6PGVk5IzujI7eiY/builds/SkXibJW3n4Wcwwa1l/openapi.json
