producthunt

Overview of producthunt skill

What the producthunt skill does

The producthunt skill is a lightweight Product Hunt data retrieval workflow built around the official GraphQL API. It helps an agent or user fetch posts, topics, users, collections, and post comments from Product Hunt without manually composing GraphQL queries each time.

Who should install producthunt

This producthunt skill is best for people doing launch research, competitive scanning, founder outreach prep, or market discovery around Product Hunt. It is especially useful if you need structured data on specific launches, topic pages, maker profiles, or collection trends rather than a generic web summary.

Real job-to-be-done

Most users do not need “Product Hunt access” in the abstract. They need to answer practical questions fast: what launched today, how a product performed, which topics are active, who made a launch, what comments say, or which collections matter for discovery. The producthunt skill is built for that operational retrieval job.

Why use this instead of a normal prompt

A normal prompt can guess or summarize public pages, but this producthunt skill gives you a repeatable path to query Product Hunt directly via scripts like scripts/get_post.py, scripts/get_posts.py, and scripts/get_user.py. That matters when you want cleaner identifiers, pagination, topic filtering, and JSON output for downstream analysis.

Main strengths and tradeoffs

Strengths:

• Covers the most common Product Hunt objects: posts, topics, users, collections, comments
• Uses small purpose-built scripts instead of one opaque tool
• Supports ID or slug lookups for several commands
• Offers --json on detail commands for structured reuse

Tradeoffs:

• Requires a valid PRODUCTHUNT_ACCESS_TOKEN
• Primarily retrieval-focused, not analytics-heavy
• Filtering is useful but not broad enough to replace custom GraphQL work for advanced research
• Best for terminal-based workflows, not point-and-click users

How to Use producthunt skill

Install context and prerequisites

The repository does not expose a separate package just for this skill; it lives inside ReScienceLab/opc-skills. In practice, producthunt install means cloning or adding the parent skills repo, then running the scripts from skills/producthunt.

You also need a Product Hunt developer token:
https://www.producthunt.com/v2/oauth/applications

Set it in your shell before running anything:

export PRODUCTHUNT_ACCESS_TOKEN="your_developer_token"

Quick verification before deeper use

Run a simple retrieval first to confirm auth and script wiring:

cd skills/producthunt
python3 scripts/get_posts.py --limit 3

If this fails, do not keep debugging prompts. Check token presence first, because scripts/credential.py reads only from the PRODUCTHUNT_ACCESS_TOKEN environment variable.

Files to read first

For fast adoption, read these in order:

1. skills/producthunt/SKILL.md
2. skills/producthunt/scripts/producthunt_api.py
3. skills/producthunt/scripts/get_posts.py
4. skills/producthunt/scripts/get_post.py
5. skills/producthunt/.claude-plugin/plugin.json

This order shows scope first, then shared API behavior, then the two scripts most users will actually call.

Core commands in the producthunt skill

Common entry points:

python3 scripts/get_post.py chatgpt
python3 scripts/get_post.py 12345
python3 scripts/get_posts.py --limit 20
python3 scripts/get_posts.py --topic ai --limit 10
python3 scripts/get_post_comments.py POST_ID --limit 20
python3 scripts/get_topic.py artificial-intelligence
python3 scripts/get_topics.py --query "AI" --limit 20
python3 scripts/get_user.py rrhoover
python3 scripts/get_user_posts.py rrhoover --limit 20
python3 scripts/get_collection.py SLUG_OR_ID
python3 scripts/get_collections.py --featured --limit 20

What input the skill needs

The producthunt skill works best when your request contains at least one strong identifier or filter:

• post slug or ID
• username
• topic slug
• collection slug or ID
• date window
• featured/non-featured intent
• limit for result volume

Weak input: “Look up AI launches on Product Hunt.”
Better input: “Get Product Hunt posts for topic artificial-intelligence, limit 10, then inspect comments for the top-voted result.”

Turn a rough goal into a strong prompt

If you want an agent to use the producthunt skill well, specify:

1. object type
2. identifier or filter
3. time range if relevant
4. output format
5. next action after retrieval

Example:

Use the producthunt skill to find recent Product Hunt posts in topic `ai` after 2026-01-01, limit 10. Return name, slug, votes, comments, URL, and website. Then identify the 3 most discussed launches for follow-up comment retrieval.

That is much better than:

Check Product Hunt for interesting AI launches.

Best workflow for Product Launches research

For producthunt for Product Launches, a reliable sequence is:

1. get_posts.py to scan a date range or topic
2. get_post.py for detail on shortlisted launches
3. get_post_comments.py to inspect reception and objections
4. get_user.py or get_user_posts.py to understand makers
5. get_collection.py or get_collections.py if discovery lists matter

This staged workflow avoids over-fetching and gives better context than jumping straight into comments or user profiles.

When to use JSON output

Use --json when you want to:

• feed output into another script
• compare launches systematically
• store snapshots for later analysis
• avoid lossy terminal formatting

Detail commands such as get_post.py and get_collection.py support JSON output. Prefer JSON if you are building summaries, scoring, or enrichment pipelines.

Practical filters that change result quality

A few inputs materially improve producthunt usage:

• --topic narrows broad launch noise into a usable category view
• --after and --before make trend windows explicit
• --limit prevents long noisy outputs
• --cursor matters for pagination when you need more than the first page
• --featured is useful when you only want higher-visibility launches

Without these, users often mistake “first page output” for “the market”.

Common install and runtime blockers

The biggest adoption blockers are simple:

• missing token
• running commands outside the skill directory
• using the wrong slug or username
• expecting limits above the script cap of 50 in one call
• confusing post IDs with slugs

The scripts often accept either slug or numeric ID, but not every command accepts every kind of fuzzy human phrase. Normalize your identifiers early.

What this skill does not do well

This producthunt guide should make one limitation clear: the skill retrieves Product Hunt data, but it does not automatically produce full launch strategy, ranking models, or cross-source validation. If you need broader competitive research, combine it with web, app store, social, or review data instead of treating Product Hunt as the whole market.

producthunt skill FAQ

Is producthunt skill good for beginners

Yes, if you are comfortable with a shell and environment variables. The scripts are small and task-specific, so a beginner can copy known commands quickly. The hard part is usually Product Hunt API access, not the commands themselves.

Do I need the Product Hunt API token

Yes. The producthunt skill depends on PRODUCTHUNT_ACCESS_TOKEN. Without it, the scripts cannot call the official GraphQL API.

Is this better than browsing Product Hunt manually

For repeatable retrieval, yes. Manual browsing is fine for one-off inspection, but the producthunt skill is better when you need exact slugs, paginated results, reusable JSON, or a consistent workflow across many launches.

When should I not install producthunt

Skip producthunt install if you:

• do not have API access
• only need a one-time visual browse
• want deep analytics rather than retrieval
• need no-code usage only

In those cases, the setup cost may outweigh the benefit.

Can I use producthunt skill for Product Launches monitoring

Yes, especially for daily or topic-based launch checks. It is a practical fit for tracking featured posts, scanning categories, and drilling into comments around product launches.

Does the skill support broad search across everything

Not really in the way a search engine does. It provides targeted scripts for posts, topics, users, collections, and comments. If your use case needs highly custom query logic, you may outgrow the preset commands and modify scripts/producthunt_api.py or the query scripts directly.

How to Improve producthunt skill

Start with the smallest query that proves fit

Before building a workflow around producthunt, test one narrow command:

python3 scripts/get_post.py <slug>

If that single retrieval gives you the fields you need, expand to lists, comments, and user lookups. This reduces wasted setup time.

Give stronger identifiers, not broader requests

The fastest way to improve producthunt usage is to replace vague descriptions with actual slugs, usernames, topics, or date windows. Strong identifiers reduce failed lookups and make downstream analysis cleaner.

Use a two-pass retrieval pattern

A good pattern is:

1. list query for discovery
2. detail query for shortlisted items

Example:

• First: python3 scripts/get_posts.py --topic ai --limit 10
• Then: python3 scripts/get_post.py <slug>

This is usually better than asking for comments or user history before confirming the right post.

Check comments only after validating the post

get_post_comments.py is valuable, but comment retrieval is most useful after you verify the exact post ID or slug and confirm it is worth deeper review. Otherwise you burn time on irrelevant discussion threads.

Use date windows for trend questions

If your question implies timing, encode it. “Recent” is not a query. --after YYYY-MM-DD and --before YYYY-MM-DD turn a fuzzy request into a reproducible one, which is critical for launch comparisons.

Prefer JSON when you plan to compare outputs

If you will rank launches, count themes, or merge Product Hunt data with other sources, use --json where available. Structured output improves reusability and lowers formatting cleanup work.

Watch for false confidence from Product Hunt data

A common failure mode is over-reading Product Hunt signals. Votes, comments, and featured status are useful discovery indicators, but they are not complete measures of product success. Use the producthunt skill to gather evidence, not to replace judgment.

Improve the skill by extending the scripts

If the current producthunt skill is close but not enough, the cleanest path is usually editing one of the existing scripts rather than starting from scratch. The repo already separates concerns into focused files like:

• scripts/get_posts.py
• scripts/get_post.py
• scripts/get_user.py
• scripts/get_collections.py

That makes it relatively easy to add fields, filters, or a new GraphQL query for your workflow.

Iterate after first output

After your first result, refine based on what is missing:

• wrong scope -> add topic or date filters
• too much output -> lower --limit
• not enough context -> fetch detail with get_post.py
• need audience reaction -> fetch comments
• need maker context -> fetch user data

That iteration loop is the fastest way to get better results from the producthunt guide and the skill itself.