# Product Hunt Scraper — Real-Time Launch Data (`b2b_leads/producthunt-real-time-data-scraper`) Actor

Get real-time Product Hunt data: top launches, keyword search, category browsing, full product details, and maker lead details — emails, phones, and socials scraped from product websites. Streaming JSON output, webhook support, and a free tier with pay-per-event upgrades.

- **URL**: https://apify.com/b2b\_leads/producthunt-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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 Real-Time Data — Launch & Maker Lead Data at Scale

**Turn Product Hunt launches into clean, structured product and maker-lead data.** Give it keywords, categories, or specific launch pages — and get one flat JSON row per launch, complete with name, tagline, description, topics, upvotes, comments, website, makers, and (optionally) enriched lead contact details. Rows stream into your Apify dataset **as they are collected**, so even very long runs stay light and nothing is lost mid-run.

No Product Hunt API keys. No spreadsheets. No cleanup. Just enter what you want and press **Start**.

> ⚡ **Real-time streaming output** • 🎯 **Multi-mode runs** • 🧩 **Flat, predictable JSON** • 🤝 **Lead details without filtering** • 💸 **Pay only for what you export**

***

### ✅ Pricing & free-plan note (read first)

This Actor uses Apify's **pay-per-result** model — you're charged per exported row (see [Pricing](#pricing)).

- **Apify free plan:** runs are limited to a **2-result sample** per run, and the log tells you to upgrade. This is an Apify platform plan restriction, applied transparently — it is not an error.
- **Any paid Apify plan (Bronze and above):** full, uncapped output. You get exactly what your input asks for.
- Every run also honors your **max run charge** (spending limit): the Actor finishes gracefully the moment your configured limit is reached.

Details: [Free plan limitations](#free-plan-limitations) · [Pricing](#pricing)

***

### Why this Actor

| | Product Hunt Real-Time Data | Typical scraper |
|---|---|---|
| **Speed** | Fast per-result collection, parallel enrichment | Often slow & fragile |
| **Memory** | **512 MB** default | 2–4 GB+ |
| **Setup** | Organized input UI — run immediately | Often needs tuning |
| **Output** | Flat, stable JSON field names | Messy, inconsistent |
| **Streaming** | Rows saved live during the run | Results only at the end |
| **Scale** | Up to **50,000 rows** per run | Often capped much lower |
| **Freshness** | Collected at run time ("real-time") | Cached or stale |

***

### What you get — per launch

Every row includes `featureType` and `scrapedAt` so you can filter, join, and pipe into any workflow.

| Group | Fields |
|-------|--------|
| **Identity** | `postId`, `productName`, `tagline`, `productUrl`, `websiteUrl` |
| **Content** | `description`, `topics[]` |
| **Traction** | `upvotes`, `commentsCount`, `rating`, `reviewCount` |
| **Timeline** | `featuredAt`, `publishedAt` |
| **People** | `authorName`, `lead.makerName`, `lead.makerHeadline`, `lead.makerUsername`, `lead.makerProfileUrl` |
| **Media** | `logoUrl`, `screenshotUrls[]` |
| **Lead details** | `lead.email`, `lead.phone`, `lead.socials` (twitter, linkedin, github, facebook, instagram, youtube), `lead.leadFound` |
| **Context** | `searchKeyword`, `searchCategory` (when the row came from keyword search or category browse) |

Missing values are `null` — field names are stable across runs, so your transforms won't break.

***

### Features

#### 🚀 Top Launches (on by default)

Collect the launches currently featured on Product Hunt — today's front page, straight into your dataset.

#### 🔎 Keyword Search

Add one or more keywords ("ai agent", "fintech", "notion template") and collect the launches that match. Multiple keywords run in parallel.

#### 🗂️ Category Browse

Collect recent launches from Product Hunt categories — "Artificial Intelligence", "Developer Tools", "Fintech", "Marketing" and more. Multiple categories run in parallel.

#### 📎 Product URLs

Already have launch pages? Collect full details for them directly — alone or combined with any other mode.

#### 🧩 Full product details (on by default)

Every launch is enriched with the full detail set: description, topics, upvotes, comments, rating, makers, website, logo, and screenshots. Adds a little extra time per launch.

#### 🤝 Enable lead details (on by default) — enrichment, never a filter

Adds lead contact details to each launch — maker name, headline, profile, company website, emails, phone, and social profiles — **when they are publicly available**.

**Every launch is still exported even when no lead details are found.** Nothing is ever dropped for lacking contact info, so the time and cost of a run stay predictable (this is deliberate: you always know what a run of N launches costs).

***

### Who it's for

- **Investors & scouts** — track launches in your theses by keyword and category, with traction numbers (upvotes, comments) and maker identities.
- **Growth & partnership teams** — find newly launched products with websites and maker profiles ready for outreach.
- **Sales & lead-gen teams** — maker names, emails, phones, and social profiles where publicly available, flowing straight to your CRM via webhooks.
- **Founders** — monitor your category daily: who launched, what got traction, which niches are heating up.
- **Journalists & analysts** — a clean, structured feed of product launches with descriptions and topics for trend stories.
- **AI & automation builders** — stable flat JSON for LLM prompts, scoring, and enrichment pipelines via the Apify API and MCP.
- **Data teams** — flat rows that drop straight into Postgres, BigQuery, Airtable, or Sheets.

### Use cases

- **Daily launch monitoring** — schedule a run on Top Launches + a webhook; get every new featured product in Slack or your CRM the moment it's collected.
- **Category prospecting** — collect "Artificial Intelligence" or "Fintech" launches weekly; enrich with lead details and feed your outreach queue.
- **Keyword market maps** — run several keywords in parallel ("invoice", "agent", "hr tech") and compare traction per niche.
- **Competitive watch** — collect launches in your own category; track upvotes and comments run over run.
- **Investor deal flow** — filter post-run on `upvotes` thresholds; route standouts to your pipeline by webhook.
- **Maker contact lists** — maker profile URLs, emails, and socials where publicly available, ready for partnership or press outreach.
- **AI product summaries** — feed `description`, `tagline`, and `topics` to an LLM to cluster and summarize every day's launches.
- **Content sourcing** — journalists: today's most upvoted launches with descriptions, ready to draft from.
- **Community building** — collect maker profiles from launches in your niche for ambassador and community programs.
- **Backlink & press outreach** — new products actively want visibility; their makers are reachable with public contact details.
- **Ecosystem research** — join launch data with your own datasets by stable `postId` / `websiteUrl` keys.
- **Enrich your own lists** — bring launch URLs you already have; leave with complete records.

### Quick start

1. Open the Actor in Apify Console.
2. Leave **Top Launches** on — or switch on **Keyword Search** / **Category Browse** and add terms.
3. Leave **Full product details** and **Enable lead details** on for maximum data per row.
4. Press **Start** and watch rows stream into the dataset.
5. Export as **JSON / CSV / Excel**, pull via the **Apify API**, wire up a **webhook**, or use **MCP**.

#### Example — today's top launches

```json
{
  "enableTopLaunches": true,
  "topLaunchesMaxResults": 20,
  "enableProductDetails": true,
  "enableLeadDetails": true
}
```

#### Example — keyword watch across niches

```json
{
  "enableSearch": true,
  "searchKeywords": ["ai agent", "fintech", "analytics"],
  "searchMaxResults": 15
}
```

#### Example — category prospecting

```json
{
  "enableCategoryBrowse": true,
  "categories": ["Artificial Intelligence", "Developer Tools"],
  "categoryMaxResults": 30
}
```

#### Example — enrich your own launch URLs

```json
{
  "enableTopLaunches": false,
  "enableProductUrls": true,
  "productUrls": [
    "https://www.producthunt.com/products/example-app"
  ],
  "enableProductDetails": true,
  "enableLeadDetails": true
}
```

#### Example — results to a webhook (Slack-friendly)

```json
{
  "enableTopLaunches": true,
  "topLaunchesMaxResults": 25,
  "webhookUrl": "https://hooks.slack.com/services/T000/B000/XXXX",
  "webhookFormat": "slack"
}
```

### Input reference

The input is organized into one section per collection mode. Each mode has its own **enable toggle** (all off by default except Top Launches) and its own **max results** — there is no global cap; the run's total is simply the sum of what each enabled section collects.

#### 🚀 Top Launches

| Field | Type | Default | Description |
|---|---|---|---|
| `enableTopLaunches` | boolean | `true` | Collect the launches currently featured on Product Hunt. |
| `topLaunchesMaxResults` | integer | `10` | Max launches to collect from the featured feed (1–500). |

#### 🔎 Keyword Search

| Field | Type | Default | Description |
|---|---|---|---|
| `enableSearch` | boolean | `false` | Collect launches matching the keywords below. |
| `searchKeywords` | string\[] | `[]` | Keywords or phrases — one launch set per keyword. |
| `searchMaxResults` | integer | `10` | Max matching launches **per keyword** (1–500). Matching is applied during collection, so results are best-effort for rare terms. |

#### 🗂️ Category Browse

| Field | Type | Default | Description |
|---|---|---|---|
| `enableCategoryBrowse` | boolean | `false` | Collect recent launches from the categories below. |
| `categories` | string\[] | `[]` | Product Hunt category names (e.g. `Artificial Intelligence`, `Developer Tools`). |
| `categoryMaxResults` | integer | `10` | Max launches **per category** (1–500). |

#### 🔗 Product URLs

| Field | Type | Default | Description |
|---|---|---|---|
| `enableProductUrls` | boolean | `false` | Collect full details for the launch pages below. |
| `productUrls` | string\[] | `[]` | Product Hunt product or post URLs. |

#### 🧩 Data enrichment

| Field | Type | Default | Description |
|---|---|---|---|
| `enableProductDetails` | boolean | `true` | Enrich each launch with the full detail set. Adds a little extra time per launch. |
| `enableLeadDetails` | boolean | `true` | Add lead contact details when publicly available. **Never filters** — every launch is exported either way. |

#### 📡 Webhooks & connection

| Field | Type | Default | Description |
|---|---|---|---|
| `webhookUrl` | string | `""` | Optional. Each row is saved to the dataset **and** delivered to this URL in real time. |
| `webhookFormat` | select | `json` | `json` (full record) or `slack` (message payload). |
| `proxyConfiguration` | proxy | US residential | Apify proxy settings (US residential on by default). |

Provide **at least one** enabled mode. All modes can run together in a single run — the keyword and category that produced each row are tagged on the row itself, and duplicates are removed automatically across modes.

### Output reference

Every exported record is a **flat JSON object** in the run's dataset:

| Field | Type | Description |
|---|---|---|
| `featureType` | string | `top_launch`, `keyword_search`, `category`, or `product_details`. |
| `source` | string | Which stage produced the row (e.g. `feed`, `feed+details`). |
| `scrapedAt` | string | ISO 8601 UTC timestamp of collection. |
| `postId` | string | null | Product Hunt launch post ID (stable join key). |
| `productName` | string | null | Product name. |
| `tagline` | string | null | Launch tagline. |
| `productUrl` | string | null | Product Hunt page URL for the launch. |
| `websiteUrl` | string | null | The product's own website, when available. |
| `description` | string | null | Full description (when details are on). |
| `topics` | string\[] | Product Hunt topics/categories (when details are on). |
| `upvotes` | integer | null | Launch upvotes (when details are on). |
| `commentsCount` | integer | null | Comment count (when details are on). |
| `rating` | number | null | Star rating (0–5), when available. |
| `reviewCount` | integer | null | Number of reviews, when available. |
| `featuredAt` | string | null | When the launch was featured. |
| `publishedAt` | string | null | When the launch was published. |
| `authorName` | string | null | Who posted the launch. |
| `logoUrl` | string | null | Product logo image URL. |
| `screenshotUrls` | string\[] | Product screenshot image URLs. |
| `lead` | object | null | Lead contact block (when lead details are on) — see below. |
| `searchKeyword` | string | null | The keyword that produced this row (keyword search only). |
| `searchCategory` | string | null | The category that produced this row (category browse only). |

#### Lead contact block (`lead`)

| Field | Type | Description |
|---|---|---|
| `makerName` | string | null | Maker's name, when available. |
| `makerHeadline` | string | null | Maker's headline (e.g. "Founder of Example Co"). |
| `makerUsername` | string | null | Maker's Product Hunt username. |
| `makerProfileUrl` | string | null | Maker's Product Hunt profile URL. |
| `email` | string | null | A contact email publicly available on the product's website. |
| `phone` | string | null | A contact phone publicly available on the product's website. |
| `socials` | object | Public social profile URLs: `twitter`, `linkedin`, `github`, `facebook`, `instagram`, `youtube` (each `string \| null`). |
| `websiteUrl` | string | null | The company website the details came from. |
| `leadFound` | boolean | `true` when at least one contact detail was found. Rows are exported regardless of this flag. |

#### Run summary (`OUTPUT` key-value store)

Each run also writes a summary you can read via the Apify API:

```json
{
  "totalPushed": 120,
  "enabledFeatures": ["top_launches", "product_details", "lead_details"],
  "errors": [],
  "spendingLimitReached": false,
  "paywall": {
    "detected": true,
    "isPaying": true,
    "pricingTier": "SILVER",
    "blocked": false,
    "limited": false,
    "mode": "limit",
    "freeTierMaxItems": null
  },
  "finishedAt": "2026-09-25T12:00:00.000Z"
}
```

| Summary field | Meaning |
|---|---|
| `totalPushed` | Rows exported this run. |
| `enabledFeatures` | Modes that ran (e.g. `top_launches`, `keyword_search`, `category_browse`, `product_urls`, `product_details`, `lead_details`). |
| `errors` | Non-fatal failures, expressed as fixed user-facing sentences. |
| `spendingLimitReached` | `true` when your max run charge was reached — the run then finishes gracefully. |
| `paywall` | Free-plan gate transparency: `detected`, `isPaying`, `pricingTier`, `blocked`, `limited`, `mode`, `freeTierMaxItems`. |
| `finishedAt` | When the run wrapped up. |

#### Dataset views

The dataset ships with ready-made views: **Overview**, **Launches**, and **Leads** — switch between them in the Console's Dataset tab.

***

### Webhooks — real-time delivery to your stack

Every row is **always** saved to the run's dataset. Optionally, set **Webhook URL** and each row is *also* delivered to your URL the moment it is collected — perfect for CRMs, Slack, Zapier, Make, n8n, or Google Sheets.

| Setting | Values |
|---|---|
| `webhookUrl` | Your receiving URL (any service that accepts a POST). |
| `webhookFormat` | `json` = the full record; `slack` = Slack message payload. |

**Payload example (`json` format):**

```json
{
  "featureType": "top_launch",
  "productName": "Example App",
  "tagline": "Turn screenshots into demo videos",
  "description": "Example App helps you create polished demo videos from screenshots in minutes.",
  "topics": ["Artificial Intelligence", "Video"],
  "upvotes": 127,
  "commentsCount": 21,
  "productUrl": "https://www.producthunt.com/products/example-app",
  "websiteUrl": "https://example.app",
  "lead": {
    "makerName": "Jane Doe",
    "makerHeadline": "Founder of Example",
    "makerUsername": "janedoe",
    "makerProfileUrl": "https://www.producthunt.com/@janedoe",
    "email": "jane@example.app",
    "phone": null,
    "socials": { "twitter": "https://x.com/janedoe", "linkedin": null },
    "leadFound": true
  },
  "scrapedAt": "2026-09-25T12:00:00.000Z"
}
```

**Payload example (`slack` format):**

```json
{
  "text": ":rocket: *Example App*\nTurn screenshots into demo videos\n*Topics:* Artificial Intelligence, Video\n*Upvotes:* 127  •  *Comments:* 21\n*Maker:* Jane Doe • Founder of Example\n*Email:* jane@example.app\n*Website:* https://example.app\n<View on Product Hunt|...>"
}
```

Webhook payloads contain the same curated fields as the dataset — nothing else. Failed deliveries are logged as a single warning (`Webhook delivery failed`) and **never** interrupt the run or dataset writes.

**Apify's own webhooks** (run succeeded / failed / aborted) are configured separately under your run's *Storage* → *Webhooks* in the Console and work with any Actor.

***

### Integrations — API, MCP, and automations

#### Apify API

Pull results programmatically as JSON, CSV, or Excel:

- `GET https://api.apify.com/v2/datasets/{DATASET_ID}/items` — your rows.
- Full reference: [Apify API v2](https://docs.apify.com/api/v2)

Start and monitor runs with `POST /v2/acts/{actorId}/runs` — schedule them with [Schedules](https://docs.apify.com/platform/schedules) for daily launch or lead refreshes.

#### MCP usage (AI assistants)

Use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants (Claude, ChatGPT, Cursor, and others) can **run this Actor and read its results directly in chat**:

1. Connect the Apify MCP server to your assistant ([setup guide](https://docs.apify.com/platform/integrations/mcp)).
2. Ask in natural language — the assistant calls this Actor with the right input.
3. Results come back as dataset items the assistant can summarize, tabulate, or chain onward.

Example prompts:

```
"Collect today's top 20 Product Hunt launches and summarize each in one sentence."
"Run the Product Hunt actor for the Artificial Intelligence category and list the 10 most upvoted launches in a table."
"Find Product Hunt launches matching 'invoice' and pull maker names and websites for outreach."
```

Typical MCP flow:

```
User: "Collect 10 AI launches from Product Hunt and draft outreach to their makers"
→ MCP runs Actor with enableTopLaunches=true, topLaunchesMaxResults=10, enableCategoryBrowse=true, categories=["Artificial Intelligence"], categoryMaxResults=10
→ MCP reads dataset items (productName, upvotes, lead.makerName, lead.email)
→ Assistant drafts the outreach
```

#### LLM & RAG pipelines

Output is stable, flat JSON — ideal for ChatGPT, Claude, Gemini, LangChain, and LlamaIndex:

```json
{
  "featureType": "top_launch",
  "productName": "Example App",
  "upvotes": 127,
  "topics": ["Artificial Intelligence"],
  "lead": { "makerName": "Jane Doe", "email": "jane@example.app" },
  "scrapedAt": "2026-09-25T12:00:00.000Z"
}
```

Workflow: run the Actor → fetch dataset items via the API → pass records to your LLM or vector store.

#### Native integrations

Push rows straight from the dataset to **Google Sheets, Airtable, Dropbox, Google Drive, Zapier, Make, and more** via [Apify Integrations](https://docs.apify.com/platform/integrations) — no code required.

***

### Pricing

- **Pay per exported result** (pay-per-event). You are charged for rows actually delivered to your dataset — not for time, and not for work you don't receive.
- **Spending limit respected:** if you set a max charge for a run in Apify, the Actor stops gracefully the moment that limit is reached, with a clear status message — never an overrun. See [Apify's pay-per-event docs](https://docs.apify.com/actors/publishing/monetize/pay-per-event#respect-user-spending-limits).
- **Cost levers:** lower each section's **Max results**, enable only the modes you need, and turn off **Full product details** / **Enable lead details** for lighter runs.

#### Free plan limitations

Apify free-plan accounts are limited to a **2-result sample per run** (across all enabled modes). The run log shows an explicit notice to **upgrade to a paid Apify plan for full, unlimited data**, and the run's `paywall` summary object records the decision (`detected`, `isPaying`, `pricingTier`, `blocked`, `limited`). This is a transparent platform plan restriction — runs finish cleanly; nothing errors. **Paid plans (Bronze and above) always get the full, normal output with no cap.**

***

### Performance & scale

- **Streaming:** rows are written to the dataset as they are collected — memory stays light and a long run never loses completed work.
- **Parallel enrichment:** multiple launches are enriched concurrently; **512 MB** default memory is plenty (configurable up to 2 GB).
- **10,000-second** run timeout — supports very large multi-mode runs.
- **Per-section scaling:** each mode collects up to its own max results, so run size is exactly what you configure per section.
- **US residential connectivity** enabled by default for consistent results.
- **Lead details** add a little extra time per launch; turn the toggle off for the fastest possible runs.

***

### FAQ

**Do I need a Product Hunt API key or account?**
No. Just pick your modes and press Start.

**What does "real-time" mean here?**
Data is collected when your run executes — not served from a stale cache. Schedule runs to keep it fresh.

**I'm on the Apify free plan — why only 2 results?**
That's the platform free-plan restriction for this Actor: 2 results per run across all enabled modes plus an upgrade notice in the log. Upgrade to any paid Apify plan for full, unlimited output. See [Free plan limitations](#free-plan-limitations).

**Will launches without contact details be dropped?**
Never. **Enable lead details** adds contact information when it's publicly available — it never filters. Every collected launch is exported, so run time and cost stay predictable.

**Why does a run take a little longer with lead details on?**
Lead details add a little extra time per launch. Turn the toggle off if you only need product facts.

**Can I run several modes at once?**
Yes — Top Launches, Keyword Search, Category Browse, and Product URLs can all run in the same run. Each row is tagged with the keyword/category that produced it, and duplicates are removed automatically across modes.

**How is the run size controlled?**
Per section: each enabled mode collects up to its own "Max results" value (per feed, per keyword, per category — or one per URL). There is no separate global cap; the run's total is the sum of what each enabled section collects.

**How many keywords/categories can I add?**
As many as you like. They run in parallel; `searchMaxResults` applies per keyword and `categoryMaxResults` per category.

**Can I filter by upvotes or category?**
You can collect broadly and filter post-run — rows carry `upvotes`, `topics`, and `featureType`, so simple spreadsheet/API filtering gives you full control without unpredictable run times.

**Some launches have no `postId` or empty fields — why?**
Every field is optional and filled when available; missing values are `null`. Launches are only exported when successfully collected; unavailable ones are skipped and noted in the log with a fixed, generic message.

**How do webhooks work?**
Set `webhookUrl` (and `webhookFormat`) and each row is delivered to your URL as it is collected, in addition to being saved to the dataset. Failures log one warning and never stop the run.

**Can AI assistants use this Actor?**
Yes — connect the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) and run it with natural language. See [MCP usage](#mcp-usage-ai-assistants).

**How do I control cost?**
Keep each section's "Max results" realistic, enable only the modes you need, and set a run spending limit in Apify — the Actor honors it and stops gracefully.

**What does `spendingLimitReached: true` mean?**
Your configured max charge for that run was reached. The run wrapped up cleanly with everything collected so far saved.

**What do the `paywall` fields mean?**
They make the free-plan gate visible in the run output: whether it was detected, whether the account is paying, the pricing tier, and whether results were capped or blocked.

**Is the data public?**
The Actor collects publicly displayed launch information only.

**Which categories work?**
Any category Product Hunt lists. Use the display name (e.g. "Artificial Intelligence", "Developer Tools", "Marketing").

**How often can I run it?**
As often as you like, bounded by your Apify plan and spending limits. Scheduled runs are supported.

**What does "Webhook delivery failed" in the log mean?**
Your receiving URL rejected or timed out the delivery. Dataset writes are unaffected — fix the receiver or re-deliver from your own queue.

**How do I export data?**
Console export (JSON/CSV/Excel), the [Apify API](https://docs.apify.com/api/v2), native integrations, or your webhook.

***

### Support

Open an issue on this Actor's GitHub repository or contact the developer through the Apify Store page.

### License

See repository for license details.

# Actor input Schema

## `enableTopLaunches` (type: `boolean`):

Collect the launches currently featured on Product Hunt. Enabled by default.

## `topLaunchesMaxResults` (type: `integer`):

Maximum launches to collect from the featured feed.

## `enableSearch` (type: `boolean`):

Find launches matching your keywords (e.g. "ai agent", "fintech", "notion template").

## `searchKeywords` (type: `array`):

One keyword or phrase per row — e.g. "ai agent", "crm", "bitcoin".

## `searchMaxResults` (type: `integer`):

Maximum matching launches to collect per keyword. Matching is applied during collection, so results are best-effort for rare terms.

## `enableCategoryBrowse` (type: `boolean`):

Browse launches by Product Hunt topic/category (e.g. Artificial Intelligence, Fintech, Developer Tools).

## `categories` (type: `array`):

Product Hunt category names, one per row — e.g. "Artificial Intelligence", "Fintech", "Developer Tools", "Marketing", "SaaS".

## `categoryMaxResults` (type: `integer`):

Maximum launches to collect per category.

## `enableProductUrls` (type: `boolean`):

Collect full details for specific Product Hunt product pages you already have.

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

Product Hunt product or post URLs, one per row — e.g. https://www.producthunt.com/products/example-app

## `enableProductDetails` (type: `boolean`):

Enrich every launch with the full detail set: description, topics, upvotes, comments, maker info, website, rating, media. Adds a little extra time per launch.

## `enableLeadDetails` (type: `boolean`):

Add lead contact details to each launch when they are available: maker name and profile, company website, emails, phone, and social profiles. Every launch is exported even when no lead details are found — this option never filters results.

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also POSTed to this URL (CRM, Slack incoming webhook, Zapier, Make, n8n, Google Sheets).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

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

Apify residential proxy (US) is enabled by default for reliable collection.

## Actor input object example

```json
{
  "enableTopLaunches": true,
  "topLaunchesMaxResults": 10,
  "enableSearch": false,
  "searchKeywords": [],
  "searchMaxResults": 10,
  "enableCategoryBrowse": false,
  "categories": [],
  "categoryMaxResults": 10,
  "enableProductUrls": false,
  "productUrls": [],
  "enableProductDetails": true,
  "enableLeadDetails": true,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every row from all enabled modes.

## `topLaunches` (type: `string`):

Launch rows from the Top Launches mode.

## `leads` (type: `string`):

Maker and company contact details (when Enable lead details is on).

# 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 = {
    "enableTopLaunches": true,
    "topLaunchesMaxResults": 10,
    "searchKeywords": [],
    "searchMaxResults": 10,
    "categories": [],
    "categoryMaxResults": 10,
    "productUrls": [],
    "enableProductDetails": true,
    "enableLeadDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/producthunt-real-time-data-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 = {
    "enableTopLaunches": True,
    "topLaunchesMaxResults": 10,
    "searchKeywords": [],
    "searchMaxResults": 10,
    "categories": [],
    "categoryMaxResults": 10,
    "productUrls": [],
    "enableProductDetails": True,
    "enableLeadDetails": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/producthunt-real-time-data-scraper").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 '{
  "enableTopLaunches": true,
  "topLaunchesMaxResults": 10,
  "searchKeywords": [],
  "searchMaxResults": 10,
  "categories": [],
  "categoryMaxResults": 10,
  "productUrls": [],
  "enableProductDetails": true,
  "enableLeadDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/producthunt-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/producthunt-real-time-data-scraper"
        }
    }
}
```

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/dLqgAZg70TOFoDsaU/builds/hG08FZY0mdpV6Tm9B/openapi.json