# ProductHunt Product Listings Scraper (`ecomscrape/producthunt-product-listings-scraper`) Actor

Product Hunt Product Listings Scraper automates extraction of comprehensive product data including ratings, reviews, categories, and founder information. Efficiently collect startup intelligence from the world's leading product discovery platform for competitive research, trend analysis.

- **URL**: https://apify.com/ecomscrape/producthunt-product-listings-scraper.md
- **Developed by:** [ecomscrape](https://apify.com/ecomscrape) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Contact

If you encounter any issues or need to exchange information, please feel free to contact us through the following link:
[My posts](https://apify.com/ecomscrape)

## Product Hunt Product Listings Scraper: Extract Startup & Product Launch Data

### Introduction

Product Hunt stands as the world's premier platform for discovering and launching new products, serving as a daily showcase where makers share their latest creations with an engaged community of early adopters, investors, and tech enthusiasts. With thousands of product launches spanning AI tools, SaaS platforms, developer tools, mobile apps, and countless other categories, Product Hunt provides unparalleled visibility into emerging technology trends and startup innovation.

For venture capitalists conducting market research, product managers tracking competitive landscapes, entrepreneurs analyzing successful launches, or market analysts studying innovation trends, accessing this structured product data is invaluable. However, manually collecting information across hundreds of products and categories is impractical for systematic analysis.

The Product Hunt Product Listings Scraper automates this data extraction process. Whether you're identifying promising startups for investment, analyzing product positioning strategies, tracking category trends, or building comprehensive databases of new technology launches, this scraper enables efficient data collection that supports strategic decision-making.

### Scraper Overview

The Product Hunt Product Listings Scraper is a specialized tool designed to extract detailed product information from Product Hunt's category pages and search results. It captures comprehensive data including product metadata, engagement metrics, founder information, and community validation signals.

The scraper offers key advantages including batch URL processing, configurable item limits per page, and error handling that continues operation even when individual URLs fail. It's valuable for VCs and investors tracking emerging startups, competitive intelligence teams monitoring product launches, market researchers analyzing innovation trends, product managers studying successful positioning strategies, and startup founders benchmarking against competitors.

The tool extracts rich metadata including product categories and tags, community engagement metrics (reviews, followers), founder reputation indicators, product status signals (badges, top product status), and detailed product descriptions and taglines that reveal positioning strategies.

### Input and Output Details

Example url 1: https://www.producthunt.com/search?q=vercel&page=2

Example url 2: https://www.producthunt.com/search?q=tool

Example url 3: https://www.producthunt.com/categories/llms

Example Screenshot of posts list page:
    
![](https://i.ibb.co/gLDqt63F/Screenshot-from-2026-04-09-20-31-12.png)

#### Input Format

The scraper accepts JSON configuration supporting both URL-based and filter-based extraction methods.

##### Scrape with URLs:

```json
{
  "urls": [
    "https://www.producthunt.com/categories/llms"
  ],
  "max_items_per_url": 100,
  "ignore_url_failures": true
}
````

**The `urls` parameter**: Add URLs of product list pages from Product Hunt categories, search results, or topic pages. Navigate to Product Hunt, browse to your target category or search results, then copy the URL. You can add multiple URLs to extract from different categories or search queries in a single run.

**The `max_items_per_url` parameter**: Limit the number of products to extract per URL. Default is 20, but can be increased for comprehensive category coverage. Set higher values (50-100) for complete category analysis.

**The `ignore_url_failures` parameter**: If true, the scraper continues running even if some URLs fail after maximum retries. Essential for batch processing multiple categories without interruption.

*When using URLs, all filter-based options are disabled.*

##### Scrape with Search Filters:

```json
{
  "keyword": "ai",
  "page": 1,
  "max_items_per_url": 20
}
```

**The `keyword` parameter**: Enter search terms to find products (e.g., "ai", "productivity", "developer tools", "saas"). The scraper automatically searches Product Hunt and extracts results.

**The `page` parameter**: Specify which results page to scrape. Enables pagination through large result sets for comprehensive coverage.

*When using search filters, leave the `urls` field empty.*

#### Output Format

```json
[
  {
  "id": "594550",
  "detailed_reviews_count": 725,
  "posts_count": 30,
  "latest_launch": {
    "__typename": "Post",
    "id": "1114441",
    "scheduled_at": "2026-04-03T00:01:00-07:00"
  },
  "structured_data": {
    "@context": "http://schema.org",
    "@id": "https://www.producthunt.com/products/openai",
    "@type": [
      "WebApplication",
      "Product"
    ],
    "url": "https://www.producthunt.com/products/openai",
    "name": "OpenAI",
    "description": "The most powerful platform for building AI products.\r\n\r\nBuild and scale AI experiences powered by industry-leading models and tools.",
    "date_published": "2024-07-21T06:01:12.997-07:00",
    "date_modified": "2026-04-09T06:16:48.586-07:00",
    "image": "https://ph-files.imgix.net/f904aec8-e324-4aed-ae3b-ff68795ce44f.png?auto=format",
    "screenshot": [
      "https://ph-files.imgix.net/b84be24d-4ae6-408a-b83f-deaa53461472.jpeg?auto=format&fit=crop",
      "https://ph-files.imgix.net/f7269af3-58d5-45ac-b1c5-976f9a84f39e.jpeg?auto=format&fit=crop",
      "https://ph-files.imgix.net/b5d0fa3e-10b1-4e25-b6ee-736c1436c3a7.jpeg?auto=format&fit=crop",
      "https://ph-files.imgix.net/dc171d60-3acf-467b-a90e-79417d927afa.jpeg?auto=format&fit=crop",
      "https://ph-files.imgix.net/13fcea8a-f852-4cc5-b1fb-d348ea8cafa4.webp?auto=format&fit=crop"
    ],
    "aggregate_rating": {
      "@type": "AggregateRating",
      "rating_count": 725,
      "rating_value": "4.98",
      "worst_rating": 1,
      "best_rating": 5
    },
    "operating_system": "Web",
    "offers": {
      "@type": "Offer",
      "price": 0,
      "price_currency": "USD"
    },
    "application_category": "Cars",
    "author": [
      {
        "@type": "Person",
        "name": "Sam Altman",
        "image": "https://ph-avatars.imgix.net/68254/original.jpeg?auto=format&crop=faces&fit=crop&h=100&w=100",
        "url": "https://www.producthunt.com/@sama"
      },
      {
        "@type": "Person",
        "name": "Greg Brockman",
        "image": "https://ph-avatars.imgix.net/3238387/original.jpeg?auto=format&crop=faces&fit=crop&h=100&w=100",
        "url": "https://www.producthunt.com/@greg_brockman1"
      },
      {
        "@type": "Person",
        "name": "Kevin Weil",
        "image": "https://ph-avatars.imgix.net/167576/original.jpeg?auto=format&crop=faces&fit=crop&h=100&w=100",
        "url": "https://www.producthunt.com/@kevinweil"
      }
    ]
  },
  "slug": "openai",
  "name": "OpenAI",
  "tagline": "APIs and tools for building AI products",
  "logo_uuid": "f904aec8-e324-4aed-ae3b-ff68795ce44f.png",
  "reviews_rating": 4.98,
  "reviews_count": 725,
  "categories": [
    {
      "__typename": "ProductCategory",
      "id": "126",
      "name": "LLMs",
      "slug": "llms",
      "path": "/categories/llms"
    },
    {
      "__typename": "ProductCategory",
      "id": "1783",
      "name": "Foundation Models",
      "slug": "foundation-models",
      "path": "/categories/foundation-models"
    }
  ],
  "tags": [
    "code generation",
    "open-weight models",
    "assistants api",
    "realtime voice api",
    "text-to-video generation",
    "android",
    "windows",
    "health & fitness",
    "productivity",
    "task management",
    "messaging",
    "api",
    "open source",
    "writing",
    "user experience",
    "robots",
    "spreadsheets",
    "saas",
    "software engineering",
    "calendar",
    "developer tools",
    "artificial intelligence",
    "github",
    "bots",
    "tech",
    "medical",
    "audio",
    "business",
    "data & analytics",
    "development",
    "photo & video",
    "science",
    "digital art",
    "video",
    "photo editing",
    "security",
    "foundation models"
  ],
  "embedding_summary": null,
  "is_top_product": false,
  "badges": {
    "__typename": "Connection",
    "edges": [
      {
        "__typename": "BadgeEdge",
        "node": {
          "__typename": "TopPostBadge",
          "id": "36005",
          "post": {
            "__typename": "Post",
            "id": "307955",
            "slug": "codex-by-openai",
            "name": "Codex by OpenAI",
            "product": {
              "__typename": "Product",
              "id": "594550",
              "slug": "openai"
            },
            "redirect_to_product": {
              "__typename": "Product",
              "id": "594550",
              "slug": "openai"
            }
          },
          "position": 2,
          "period": "monthly",
          "date": "2021-08-11"
        }
      },
      {
        "__typename": "BadgeEdge",
        "node": {
          "__typename": "TopPostBadge",
          "id": "8422230",
          "post": {
            "__typename": "Post",
            "id": "1090795",
            "slug": "gpt-5-4-5",
            "name": "GPT‑5.4",
            "product": {
              "__typename": "Product",
              "id": "594550",
              "slug": "openai"
            },
            "redirect_to_product": {
              "__typename": "Product",
              "id": "594550",
              "slug": "openai"
            }
          },
          "position": 4,
          "period": "weekly",
          "date": "2026-03-06"
        }
      },
      {
        "__typename": "BadgeEdge",
        "node": {
          "__typename": "TopPostBadge",
          "id": "7796892",
          "post": {
            "__typename": "Post",
            "id": "1051091",
            "slug": "chatgpt-images",
            "name": "ChatGPT Images",
            "product": {
              "__typename": "Product",
              "id": "594550",
              "slug": "openai"
            },
            "redirect_to_product": {
              "__typename": "Product",
              "id": "594550",
              "slug": "openai"
            }
          },
          "position": 4,
          "period": "weekly",
          "date": "2025-12-17"
        }
      }
    ]
  },
  "is_no_longer_online": false,
  "founder_reviews_count": 700,
  "founder_shoutouts": [
    {
      "__typename": "DetailedReview",
      "id": "289538",
      "product": {
        "__typename": "Product",
        "id": "594550"
      },
      "from_post": {
        "__typename": "Post",
        "id": "662771",
        "slug": "supabase-ai-assistant-lw24",
        "name": "Supabase AI Assistant [LW24]",
        "product": {
          "__typename": "Product",
          "id": "106850",
          "slug": "supabase"
        },
        "badges": {
          "__typename": "Connection",
          "edges": [
            {
              "__typename": "BadgeEdge",
              "node": {
                "__typename": "TopPostBadge",
                "id": "5015631",
                "position": 2,
                "period": "daily",
                "date": "2024-12-03"
              }
            }
          ]
        },
        "thumbnail_image_uuid": "e1faa693-596a-4504-bd20-187ed1ce2f15.gif",
        "product_state": "default"
      }
    },
    {
      "__typename": "DetailedReview",
      "id": "380487",
      "product": {
        "__typename": "Product",
        "id": "594550"
      },
      "from_post": {
        "__typename": "Post",
        "id": "825473",
        "slug": "orate-2",
        "name": "Orate",
        "product": {
          "__typename": "Product",
          "id": "435808",
          "slug": "vercel"
        },
        "badges": {
          "__typename": "Connection",
          "edges": [
            {
              "__typename": "BadgeEdge",
              "node": {
                "__typename": "TopPostBadge",
                "id": "5302108",
                "position": 5,
                "period": "daily",
                "date": "2025-01-31"
              }
            }
          ]
        },
        "thumbnail_image_uuid": "d6389dff-56d6-4f2f-bd77-66bac4281198.png",
        "product_state": "default"
      }
    },
    {
      "__typename": "DetailedReview",
      "id": "287720",
      "product": {
        "__typename": "Product",
        "id": "594550"
      },
      "from_post": {
        "__typename": "Post",
        "id": "608665",
        "slug": "lovable",
        "name": "Lovable",
        "product": {
          "__typename": "Product",
          "id": "566141",
          "slug": "lovable"
        },
        "badges": {
          "__typename": "Connection",
          "edges": [
            {
              "__typename": "BadgeEdge",
              "node": {
                "__typename": "TopPostBadge",
                "id": "4967837",
                "position": 1,
                "period": "daily",
                "date": "2024-11-21"
              }
            }
          ]
        },
        "thumbnail_image_uuid": "dc66b047-9813-46c2-9d3f-5a132f705501.gif",
        "product_state": "default"
      }
    }
  ],
  "followers_count": 12427,
  "is_subscribed": false,
  "from_url": "https://www.producthunt.com/categories/llms"
}
]
```

The scraper returns structured product data with fields providing specific intelligence value:

- **ID**: Unique product identifier in Product Hunt. *Critical for tracking products over time, preventing duplicates, and linking related data.*

- **Detailed Reviews Count**: Number of in-depth product reviews. *Indicates product validation depth and community engagement quality.*

- **Posts Count**: Number of times product was posted/featured. *Shows relaunch frequency and sustained market presence.*

- **Latest Launch**: Timestamp of most recent product launch. *Essential for tracking launch timing, identifying new vs. established products.*

- **Structured Data**: Product schema metadata. *Contains additional structured information for enriched analysis.*

- **Slug**: URL-friendly product identifier. *Used for constructing product page URLs and clean data references.*

- **Name**: Official product name. *Core identifier for product tracking and analysis.*

- **Tagline**: Product's one-line value proposition. *Reveals positioning strategy, target audience, and key benefits messaging.*

- **Logo UUID**: Product logo identifier. *Enables visual brand analysis and logo retrieval.*

- **Reviews Rating**: Average product rating from reviews. *Key quality indicator and social proof metric.*

- **Reviews Count**: Total number of product reviews. *Measures community validation and engagement breadth.*

- **Categories**: Product category classifications. *Essential for market segmentation, category trend analysis, and competitive set identification.*

- **Tags**: Product tags and keywords. *Reveals product features, use cases, and positioning themes.*

- **Embedding Summary**: AI-generated product summary. *Provides quick product understanding and semantic analysis capabilities.*

- **Is Top Product**: Boolean indicating top product status. *Identifies highest-performing launches and market leaders.*

- **Badges**: Achievement badges earned. *Shows product milestones, special recognition, and platform engagement.*

- **Is No Longer Online**: Product availability status. *Identifies discontinued products for market evolution analysis.*

- **Founder Reviews Count**: Reviews written by founder. *Indicates founder engagement with community and customer feedback.*

- **Founder Shoutouts**: Founder recognition metrics. *Shows founder reputation and credibility in Product Hunt community.*

- **Followers Count**: Number of product followers. *Measures ongoing interest and community building success.*

- **Is Subscribed**: Subscription status indicator. *Relevant for user-specific tracking when authenticated.*

Each field enables specific analyses: market trend identification, competitive positioning assessment, launch success factor analysis, founder credibility evaluation, and product lifecycle tracking.

### Usage Guide

#### Option 1: Scraping with URLs

**Category-Based Extraction:**

Navigate to Product Hunt categories (AI, productivity, developer tools, etc.) and copy URLs. This is ideal for comprehensive category analysis.

Example categories:

- `/categories/llms` - Large language models
- `/categories/developer-tools` - Development tools
- `/categories/productivity` - Productivity apps
- `/categories/artificial-intelligence` - AI products

**Search-Based Extraction:**

Perform searches on Product Hunt for specific terms, then copy the search result URLs. Useful for focused research on specific technology types or use cases.

**Best Practices:**

- Test URLs individually before batch processing
- Set appropriate `max_items_per_url` based on category size
- Enable `ignore_url_failures` for multi-category extraction
- Organize URLs by research theme for structured analysis

#### Option 2: Scraping with Search Filters

**Keyword Strategy:**

Use targeted keywords matching your research focus:

- Technology types: "ai", "blockchain", "saas", "mobile"
- Use cases: "productivity", "analytics", "marketing", "design"
- Industries: "fintech", "healthtech", "edtech", "devtools"

**Pagination Planning:**

Start with page 1, then increment for comprehensive coverage. Most searches have 20 products per page, so plan accordingly:

- Page 1-3: ~60 products (quick overview)
- Page 1-5: ~100 products (comprehensive coverage)
- Page 1-10+: Deep category analysis

**Systematic Coverage:**

1. Define keyword list for target categories
2. Determine page depth needed per keyword
3. Run extractions sequentially or in parallel
4. Combine results for full market view

#### Advanced Research Applications

**Competitive Intelligence:**

- Track competitor product launches and iterations
- Monitor feature announcements through taglines
- Analyze engagement patterns (reviews, followers)
- Identify competitive positioning strategies

**Market Trend Analysis:**

- Track category growth through product volume
- Identify emerging subcategories via tags
- Monitor launch frequency patterns
- Analyze top product characteristics

**Investment Research:**

- Identify high-traction early-stage products
- Track founder credibility signals
- Monitor category innovation density
- Assess market validation through reviews/ratings

**Product Strategy:**

- Analyze successful tagline patterns
- Study category positioning approaches
- Benchmark engagement metrics
- Identify feature trends through tags

### Benefits and Applications

**Primary Applications:**

**VC & Investment Research:** Identify promising startups through top product status and engagement metrics, track founder reputation via shoutouts and reviews, monitor market category emergence and growth, assess product-market fit through review ratings and follower counts.

**Competitive Analysis:** Track competitor product launches and updates, analyze positioning strategies through taglines and tags, monitor engagement success patterns, identify market gaps in category coverage.

**Market Intelligence:** Analyze innovation trends across categories, identify emerging product types and features, track launch timing patterns, understand category dynamics and evolution.

**Product Development:** Benchmark successful product positioning, analyze effective tagline formulations, study feature combinations via tags, identify underserved market opportunities.

**Content & Marketing Research:** Discover trending products for coverage, identify partnership opportunities, track influencer product engagement, analyze successful launch strategies.

**Key Advantages:**

- Access to curated startup ecosystem data
- Community validation metrics unavailable elsewhere
- Founder reputation signals for credibility assessment
- Category-specific trend identification
- Launch timing and frequency analysis
- Product lifecycle tracking (active vs. discontinued)

Data integrates with analytics platforms, CRM systems, and investment research tools for immediate activation in strategic workflows.

### Conclusion

The Product Hunt Product Listings Scraper transforms manual product research into efficient automated intelligence gathering. By providing structured access to the world's leading product discovery platform, it enables data-driven insights into startup innovation, market trends, and competitive landscapes.

Whether tracking emerging technologies for investment, analyzing competitive positioning, identifying partnership opportunities, or studying successful product launches, this scraper delivers the systematic extraction capabilities needed for comprehensive market intelligence.

Ready to unlock Product Hunt's innovation data? Start extracting product intelligence today and transform your startup research capabilities.

## Your feedback

We are always working to improve Actors' performance. So, if you have any technical feedback about Product Hunt Products Listings Scraper or simply found a bug, please create an issue on the Actor's Issues tab in Apify Console.

# Actor input Schema

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

Add the URLs of the product products list page you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped after the maximum number of retries is reached.

## `keyword` (type: `string`):

Enter the keyword to search for products on producthunt.com

## `page` (type: `integer`):

Page

## `max_items_per_url` (type: `integer`):

Limit the number of items per URL you want to scrape

## Actor input object example

```json
{
  "urls": [
    "https://www.producthunt.com/search?q=vercel&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.producthunt.com/search?q=vercel&page=2"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("ecomscrape/producthunt-product-listings-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 = {
    "urls": ["https://www.producthunt.com/search?q=vercel&page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("ecomscrape/producthunt-product-listings-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 '{
  "urls": [
    "https://www.producthunt.com/search?q=vercel&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call ecomscrape/producthunt-product-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ProductHunt Product Listings Scraper",
        "description": "Product Hunt Product Listings Scraper automates extraction of comprehensive product data including ratings, reviews, categories, and founder information. Efficiently collect startup intelligence from the world's leading product discovery platform for competitive research, trend analysis.",
        "version": "0.0",
        "x-build-id": "q023gAeQvqPLBDwJh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ecomscrape~producthunt-product-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ecomscrape-producthunt-product-listings-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/ecomscrape~producthunt-product-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ecomscrape-producthunt-product-listings-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/ecomscrape~producthunt-product-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ecomscrape-producthunt-product-listings-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": {
                    "urls": {
                        "title": "URLs of the product products list page",
                        "type": "array",
                        "description": "Add the URLs of the product products list page you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Ignore URL failures",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped after the maximum number of retries is reached."
                    },
                    "keyword": {
                        "title": "Search products by keyword",
                        "type": "string",
                        "description": "Enter the keyword to search for products on producthunt.com"
                    },
                    "page": {
                        "title": "Page",
                        "type": "integer",
                        "description": "Page"
                    },
                    "max_items_per_url": {
                        "title": "Limit the number of items per URL",
                        "type": "integer",
                        "description": "Limit the number of items per URL you want to scrape"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
