# Product Hunt Scraper — Launches, Makers & Leads (`scrapesage/product-hunt-scraper`) Actor

Scrape Product Hunt launches with full data: votes, comments, ranks, topics, website, socials, funding, reviews and makers. Optionally extract maker contact emails for lead generation. Scrape by date range, topic or URL, with monitoring mode for new launches. Export JSON, CSV, Excel.

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

## Pricing

from $4.00 / 1,000 launch scrapeds

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/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 — Launches, Makers & Leads (Emails, Socials & Funding)

Extract **complete Product Hunt launch data** — votes, comments, daily/weekly/monthly ranks, topics, the full **product website, every social link, funding, employee size, reviews** and the **makers** behind each launch. Optionally turn every launch into a **ready-to-contact B2B lead** by crawling the product's own website for **contact emails, phone numbers and socials**.

No login, no API key, no browser — fast JSON extraction straight from Product Hunt's public pages. Scrape by **date range, topic or URL**, and switch on **monitoring mode** to capture only new launches.

### Why this Product Hunt scraper?

Most Product Hunt scrapers grab the name, tagline and a vote count, then stop. This actor reads Product Hunt's full embedded data and ships the **richest dataset in the category** — including the product website and maker contacts that make the data actually actionable for sales and research.

| Data | Typical scrapers | This actor |
|---|---|---|
| Name, tagline, votes, comments | ✅ | ✅ |
| Daily / weekly / monthly rank | partial | ✅ |
| Topics & categories | partial | ✅ |
| Product **website URL** | ❌ | ✅ |
| All socials (X, LinkedIn, GitHub, Instagram, Facebook, AngelList, Threads…) | ❌ | ✅ |
| Funding amount, employee size, "was in Y Combinator" | ❌ | ✅ |
| Followers, review count & rating | ❌ | ✅ |
| **Makers** (name, username, profile, avatar, badges) | ❌ | ✅ |
| Maker/company **contact emails + phone** (from the product website) | ❌ | ✅ opt-in |
| Lead score (0–100) per launch | ❌ | ✅ |
| **Monitoring mode** — only new launches | ❌ | ✅ |

### Use cases

- **Lead generation** — every launch is a freshly funded, in-market company. Capture the website, makers and **contact emails**, score them, and push straight into your CRM or outreach sequence.
- **Startup & market intelligence** — track new products by topic (AI, dev tools, SaaS, fintech) with votes, funding and YC signals to spot trends before they scale.
- **Competitor monitoring** — watch your category daily and get alerted the moment a competitor or adjacent tool launches.
- **Investor & deal sourcing** — surface newly launched, high-traction products with funding and team-size signals.
- **Recruiting** — find makers and fast-growing startups by topic, with profiles and links straight from each launch.
- **Content & newsletters** — power "best new products" digests with structured, ranked launch data.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Product Hunt Scraper**, set how far back to scrape (or a date range / topics), and click **Start**.
3. Watch launches stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "daysBack": 3,
    "topics": ["artificial-intelligence", "developer-tools"],
    "includeProductDetails": true,
    "enrichMakerEmails": true,
    "monitorMode": false,
    "maxItems": 0
}
````

- **daysBack** *(default 7)* — scrape the daily leaderboards for the last N days (including today). The simplest control.
- **dateFrom / dateTo** *(YYYY-MM-DD)* — scrape an explicit range of daily leaderboards; overrides `daysBack`.
- **topics** — also scrape Product Hunt topic pages by slug (`artificial-intelligence`, `saas`, `marketing`, …).
- **startUrls** — also scrape specific PH URLs: leaderboards, topic pages, or individual `/products/<slug>` / `/posts/<slug>` pages.
- **includeProductDetails** *(default true)* — open each launch's product page for website, full description, all socials, funding, employee size, reviews, categories and makers.
- **enrichMakerEmails** *(default false)* — crawl each product's own website (home + contact/about) for emails, phone and extra socials. PH never exposes emails — this is the only way to get them.
- **monitorMode** *(default false)* — output only launches not seen in previous runs (see Automate & schedule).
- **maxItems** *(default 0 = no limit)* — cap the number of launches, handy for quick test runs.
- **maxConcurrency** *(default 8)* — parallel page fetches.
- **proxyConfiguration** — proxy settings (Apify proxy by default).

### Output

One record per launch (`type: "launch"`):

```json
{
    "type": "launch",
    "postId": "1166716",
    "productId": "1131568",
    "name": "Firma.dev",
    "tagline": "E-signatures API for your app averaging ~3¢ per envelope",
    "description": "At €0.029 per envelope, Firma.dev runs ~99% cheaper than legacy e-sign tools…",
    "url": "https://www.producthunt.com/posts/firma-dev-2",
    "productUrl": "https://www.producthunt.com/products/firma-dev",
    "websiteUrl": "https://firma.dev",
    "votesCount": 352,
    "commentsCount": 43,
    "reviewsCount": 12,
    "reviewsRating": 5,
    "followersCount": 210,
    "dailyRank": 1,
    "weeklyRank": 14,
    "monthlyRank": 32,
    "featuredAt": "2026-06-12T00:01:00-07:00",
    "topics": [{ "id": "88", "slug": "api-1", "name": "API" }, { "id": "267", "slug": "developer-tools", "name": "Developer Tools" }],
    "categories": ["Developer Tools", "API"],
    "pricing": "freemium",
    "isFree": false,
    "fundingAmount": null,
    "employeeSize": "1-10",
    "wasInYCombinator": false,
    "makers": [
        { "name": "Chris Davis", "username": "chris_davis23", "profileUrl": "https://www.producthunt.com/@chris_davis23", "avatarUrl": "https://ph-avatars.imgix.net/…" }
    ],
    "socials": { "twitter": "https://x.com/firmadev", "github": "https://github.com/firma-dev" },
    "emails": ["hello@firma.dev"],
    "phones": [],
    "logoUrl": "https://ph-files.imgix.net/…",
    "thumbnailUrl": "https://ph-files.imgix.net/…",
    "screenshots": ["https://ph-files.imgix.net/…"],
    "leadScore": 78,
    "scrapedAt": "2026-06-13T12:00:00.000Z"
}
```

#### What to expect (field coverage)

Product Hunt is maker-entered data, so some fields are present only when the maker filled them in.

| Field group | Always present | Usually present | Present when published |
|---|---|---|---|
| Launch core (name, tagline, votes, comments, ranks, topics, timestamps) | ✅ | — | — |
| Product detail (website, description, socials, categories) | — | ✅ with `includeProductDetails` | — |
| Makers, reviews, followers | — | ✅ ~90% | — |
| Funding, employee size, YC flag | — | — | when the maker added them |
| `emails` / `phones` | — | — | with `enrichMakerEmails`, when the website lists them |

A blank field means the maker didn't publish it — not that scraping failed. Nothing is dropped, so you always get the richest dataset available.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily to capture every new launch in your category for newsletters and lead pipelines.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

**Monitoring mode + Schedules** is the recommended combo: set `monitorMode: true` and a daily [Schedule](https://docs.apify.com/platform/schedules). The schedule starts each run; monitoring mode remembers which launches were already emitted and outputs **only the new ones** — so they never conflict, and every run delivers fresh data ready to push to your CRM.

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/product-hunt-scraper').call({
    daysBack: 1,
    includeProductDetails: true,
    enrichMakerEmails: true,
    monitorMode: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} new launches & leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new launch leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored topic gets a new launch.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find today's top AI launches on Product Hunt with their websites and maker contacts" and let it run the scraper for you.

### More scrapers from scrapesage

Build a complete **B2B lead-generation & market-intelligence stack**:

- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings as hiring-intent signals from the companies you find.
- **[Facebook Ad Library Scraper](https://apify.com/scrapesage/facebook-ad-library-scraper)** — competitor ad intelligence on Meta & Instagram.
- **[Google Ads Transparency Scraper](https://apify.com/scrapesage/google-ads-transparency-scraper)** — who's advertising what on Google.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events plus organizer leads (ticket prices, emails, socials).
- **[Sched Conference Scraper](https://apify.com/scrapesage/sched-conference-scraper)** — speakers, sessions and sponsors from conference sites.
- **[Whova Event Scraper](https://apify.com/scrapesage/whova-event-scraper)** — attendees, sessions, speakers and sponsors from Whova event apps.
- **[Swapcard Exhibitor Scraper](https://apify.com/scrapesage/swapcard-exhibitor-scraper)** — exhibitor lists, speakers and contacts from Swapcard-powered events.
- **[Bark Listing Scraper](https://apify.com/scrapesage/bark-listing-scraper)** — service-provider leads from Bark.
- **[Airbnb Scraper](https://apify.com/scrapesage/airbnb-scraper)** — listings, prices and availability.

### Tips

- **Daily lead pipeline**: set `daysBack: 1`, `enrichMakerEmails: true`, `monitorMode: true` and a daily [Schedule](https://docs.apify.com/platform/schedules) — you'll get only that day's new launches, complete with contact emails.
- **Topic focus**: add `topics` (e.g. `artificial-intelligence`, `saas`) to track specific categories instead of the whole leaderboard.
- **Cost control**: keep `enrichMakerEmails` off for pure discovery; turn it on only when you need contactable leads (it adds a few requests per product website).
- **Backfill**: use `dateFrom`/`dateTo` to pull months of historical launches in one run.

### FAQ

**How do I scrape Product Hunt without the API?** This actor reads Product Hunt's public pages directly — no API key, OAuth app or login needed. You get the same (and richer) data the website shows.

**Where do the emails come from?** Never from Product Hunt (it doesn't publish emails). With `enrichMakerEmails` on, the actor visits the product's own public website and extracts publicly listed contact emails — the same thing a human visitor would see.

**Can I export to Google Sheets, CSV or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I get only new launches?** Turn on `monitorMode` and create a daily [Schedule](https://docs.apify.com/platform/schedules). Each run outputs only launches not seen before.

**Does monitoring mode conflict with the Apify scheduler?** No. The scheduler simply starts runs on a cadence; monitoring mode remembers which launches were already emitted and filters them out. They work together.

**A field is null — why?** Some makers don't publish a website, funding or socials. Fields are blank only when the data doesn't exist, not because the scraper skipped them.

**Is scraping Product Hunt legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and Product Hunt's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `daysBack` (type: `integer`):

Scrape the daily Product Hunt leaderboards for the last N days (including today). The simplest way to pull recent launches. Ignored if you set a Date range, Topics, or Start URLs.

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

Start of an explicit date range of daily leaderboards to scrape, e.g. `2026-06-01`. Overrides Days back.

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

End of the date range (inclusive), e.g. `2026-06-13`. Defaults to today when only Date from is set.

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

Also scrape these Product Hunt topic pages. Use the topic slug from the URL, e.g. `artificial-intelligence`, `developer-tools`, `saas`, `marketing`.

## `startUrls` (type: `array`):

Also scrape specific Product Hunt URLs: leaderboard pages (`/leaderboard/daily/2026/6/12/all`), topic pages (`/topics/ai`), or individual product/post pages (`/products/<slug>`, `/posts/<slug>`).

## `includeProductDetails` (type: `boolean`):

Open each launch's product page to add the product website, full description, all social links, funding, employee size, reviews, categories, badges and makers. Adds one request per launch. Strongly recommended.

## `enrichMakerEmails` (type: `boolean`):

Crawl each product's own website (home + contact/about, a few pages) for contact emails, phone numbers and extra social links. Product Hunt never exposes emails — this is the only way to turn a launch into a contactable B2B lead. Requires Include product details.

## `monitorMode` (type: `boolean`):

Only output launches that were NOT seen in previous runs of this Actor. Combine with Apify Schedules to capture only fresh launches each day. This does not conflict with the scheduler — the schedule starts the run, while monitoring mode filters out anything already emitted by earlier runs.

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

Named key-value store used to remember which launches were already emitted (for Monitoring mode). Use one name per monitored search so their histories stay separate.

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

Maximum number of launches to output (0 = no limit). Handy for quick, cheap test runs.

## `maxConcurrency` (type: `integer`):

Maximum number of pages fetched in parallel.

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

Proxy settings. Product Hunt has no aggressive anti-bot, so the default Apify proxy is plenty.

## Actor input object example

```json
{
  "daysBack": 3,
  "includeProductDetails": true,
  "enrichMakerEmails": false,
  "monitorMode": false,
  "monitorStoreName": "product-hunt-monitor",
  "maxItems": 0,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped launch records (type: 'launch') in the default dataset.

# 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 = {
    "daysBack": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = { "daysBack": 3 }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/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 '{
  "daysBack": 3
}' |
apify call scrapesage/product-hunt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt Scraper — Launches, Makers & Leads",
        "description": "Scrape Product Hunt launches with full data: votes, comments, ranks, topics, website, socials, funding, reviews and makers. Optionally extract maker contact emails for lead generation. Scrape by date range, topic or URL, with monitoring mode for new launches. Export JSON, CSV, Excel.",
        "version": "1.0",
        "x-build-id": "w0nJnhdamv7oWU80Y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~product-hunt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-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/scrapesage~product-hunt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-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/scrapesage~product-hunt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-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": {
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Scrape the daily Product Hunt leaderboards for the last N days (including today). The simplest way to pull recent launches. Ignored if you set a Date range, Topics, or Start URLs.",
                        "default": 7
                    },
                    "dateFrom": {
                        "title": "Date from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Start of an explicit date range of daily leaderboards to scrape, e.g. `2026-06-01`. Overrides Days back."
                    },
                    "dateTo": {
                        "title": "Date to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "End of the date range (inclusive), e.g. `2026-06-13`. Defaults to today when only Date from is set."
                    },
                    "topics": {
                        "title": "Topics",
                        "type": "array",
                        "description": "Also scrape these Product Hunt topic pages. Use the topic slug from the URL, e.g. `artificial-intelligence`, `developer-tools`, `saas`, `marketing`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Also scrape specific Product Hunt URLs: leaderboard pages (`/leaderboard/daily/2026/6/12/all`), topic pages (`/topics/ai`), or individual product/post pages (`/products/<slug>`, `/posts/<slug>`).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeProductDetails": {
                        "title": "Include product details",
                        "type": "boolean",
                        "description": "Open each launch's product page to add the product website, full description, all social links, funding, employee size, reviews, categories, badges and makers. Adds one request per launch. Strongly recommended.",
                        "default": true
                    },
                    "enrichMakerEmails": {
                        "title": "Enrich maker emails (lead generation)",
                        "type": "boolean",
                        "description": "Crawl each product's own website (home + contact/about, a few pages) for contact emails, phone numbers and extra social links. Product Hunt never exposes emails — this is the only way to turn a launch into a contactable B2B lead. Requires Include product details.",
                        "default": false
                    },
                    "monitorMode": {
                        "title": "Monitoring mode (only new launches)",
                        "type": "boolean",
                        "description": "Only output launches that were NOT seen in previous runs of this Actor. Combine with Apify Schedules to capture only fresh launches each day. This does not conflict with the scheduler — the schedule starts the run, while monitoring mode filters out anything already emitted by earlier runs.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store used to remember which launches were already emitted (for Monitoring mode). Use one name per monitored search so their histories stay separate.",
                        "default": "product-hunt-monitor"
                    },
                    "maxItems": {
                        "title": "Max launches",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of launches to output (0 = no limit). Handy for quick, cheap test runs.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum number of pages fetched in parallel.",
                        "default": 8
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Product Hunt has no aggressive anti-bot, so the default Apify proxy is plenty.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
