# Gumroad Market Intelligence — Find Winning Digital Products (`lokki/gumroad-product-scraper`) Actor

Scrape Gumroad Discover by niche and keyword to find proven digital products, creators, prices, ratings, descriptions, URLs, and market signals for product validation, competitor research, affiliate discovery, and pricing strategy.

- **URL**: https://apify.com/lokki/gumroad-product-scraper.md
- **Developed by:** [Ian Dikhtiar](https://apify.com/lokki) (community)
- **Categories:** E-commerce, Automation, Other
- **Stats:** 89 total users, 14 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.90 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Gumroad Market Intelligence Scraper

Find Gumroad products worth studying before you build, copy a market, price an offer, or pick an affiliate angle.

This Apify Actor searches Gumroad Discover by niche, keyword, price, rating, and sort order. It turns public product listings into a ranked dataset with pricing signals, rating strength, niche competition, opportunity grades, and a plain-English summary for each product.

Actor name: `gumroad-product-scraper`

### What it does

Gumroad has useful market signals, but browsing it manually is slow and messy. This actor gives you a clean research table instead.

Use it to answer:

- Which products show up repeatedly in a niche?
- What price ranges are common for templates, courses, prompts, kits, and software?
- Which products have enough ratings to be worth a closer look?
- Which niches look crowded, open, premium, low-ticket, or low-confidence?
- Which creators or products should go on a watchlist?

The actor collects public Gumroad Discover listings, filters them, ranks them, then adds an intelligence layer so you can sort the results instead of eyeballing page after page.

### Best use cases

| Use case | What to look for |
|---|---|
| Product research | Products with strong ratings, good price points, and high `interestScore`. |
| Competitor research | Offer names, creator positioning, price bands, ratings, and product URLs. |
| Affiliate research | Paid products with strong social proof and a clear niche. |
| Pricing research | `price`, `pricingTier`, `priceVsNicheMedian`, and `optimalPriceRange`. |
| Niche mapping | `nicheCompetition`, `nicheDemandScore`, top products, and price density. |
| Trend scanning | Run `sort: "newest"` to find fresh listings before they are obvious. |

### What data you get

Each dataset item is one Gumroad product listing.

#### Raw product fields

- `id`
- `name`
- `creator`
- `creatorUrl`
- `productUrl`
- `thumbnailUrl`
- `price`
- `currency`
- `isFree`
- `isPayWhatYouWant`
- `ratingAverage`
- `ratingCount`
- `nativeType`
- `isVerifiedCreator`
- `niche`
- `sort`
- `scrapedAt`

#### Market intelligence fields

- `interestScore` — 0-100 composite score from popularity proxy, rating quality, and price fit.
- `scoreBreakdown` — popularity, quality, and value points.
- `dataConfidence` — tells you how much of the listing data is reliable.
- `marketSignals` — demand tier, price tier, underpriced/overpriced flags, and revenue estimate when sales data is available.
- `productHealth` — conversion proxy, social proof score, rating strength, rating momentum, viral potential, and longevity signal.
- `pricingIntel` — price category, refund-risk proxy, price-per-rating, pricing fit, and niche-derived optimal range.
- `nicheAnalysis` — niche demand score, competition density, median price, rating average, price percentile, and leader flag.
- `actionableInsights` — `BUY_NOW`, `WATCH`, or `SKIP`, plus a short explanation.
- `opportunityGrade` — `A+`, `A`, `B`, `C`, or `D`.
- `summary` — one readable sentence explaining why the product matters.

### Important data caveat

Gumroad Discover does not reliably expose every field marketers want.

In the current implementation, sales counts, descriptions, and tags may be unavailable from the Discover payload. When that happens, the actor does not fake them. It sets `salesCountSource: "unavailable"`, leaves weak fields empty, and lowers `dataConfidence`.

Translation: use the actor to find products worth studying. Do not treat every revenue or demand field as proven truth unless `dataConfidence` says the underlying data is strong.

### Input

#### Basic scan

```json
{
  "niches": ["design", "programming"],
  "keywords": [],
  "sort": "top",
  "maxResultsPerNiche": 50,
  "minPrice": 0,
  "maxPrice": 999,
  "minRating": 0
}
```

#### Find paid templates with stronger ratings

```json
{
  "niches": ["templates", "business", "self-improvement"],
  "keywords": ["notion template", "planner", "operating system"],
  "sort": "top",
  "maxResultsPerNiche": 100,
  "minPrice": 9,
  "maxPrice": 149,
  "minRating": 4
}
```

#### Watch fresh AI/productivity products

```json
{
  "niches": ["software", "programming", "templates"],
  "keywords": ["ai", "chatgpt", "prompt", "automation"],
  "sort": "newest",
  "maxResultsPerNiche": 50,
  "minPrice": 0,
  "maxPrice": 199,
  "minRating": 0
}
```

### Input fields

| Field | Type | Default | Notes |
|---|---:|---:|---|
| `niches` | array | `['design', 'programming']` | Gumroad category tags to search. Required. |
| `keywords` | array | `[]` | Optional buyer-intent search terms. Leave empty to browse the whole niche. |
| `sort` | string | `top` | Use `top` for proven products, `newest` for early signals. |
| `maxResultsPerNiche` | integer | `50` | 1-200. Start with 50, then go deeper once the query is useful. |
| `minPrice` | number | `0` | Use this to filter out free or low-ticket products. |
| `maxPrice` | number | `999` | Use this to cap premium products. |
| `minRating` | number | `0` | Use `4` or higher when quality matters more than volume. |
| `proxyConfiguration` | object | `{}` | Optional Apify proxy settings. Usually safe to leave default. |

### Supported Gumroad niches

`3d`, `audio`, `business`, `comics`, `design`, `drawing-and-painting`, `education`, `fiction`, `film`, `fitness`, `fonts`, `games`, `illustration`, `music`, `other`, `photography`, `podcasts`, `programming`, `publishing`, `science`, `self-improvement`, `software`, `sports`, `teaching-and-learning`, `templates`, `travel`, `video`, `web-design`, `writing-and-publishing`.

### Output example

```json
{
  "id": "abc123",
  "name": "Notion Business OS",
  "creator": "Creator Name",
  "creatorUrl": "https://gumroad.com/creator",
  "productUrl": "https://creator.gumroad.com/l/product",
  "thumbnailUrl": "https://public-files.gumroad.com/...",
  "price": 49,
  "currency": "usd",
  "isFree": false,
  "isPayWhatYouWant": false,
  "ratingAverage": 4.8,
  "ratingCount": 126,
  "salesCount": 0,
  "salesCountSource": "unavailable",
  "niche": "business",
  "sort": "top",
  "interestScore": 68,
  "scoreBreakdown": {
    "popularity": 10,
    "quality": 33,
    "value": 25
  },
  "dataConfidence": {
    "level": "LOW",
    "salesCountKnown": false,
    "tagsKnown": false,
    "descriptionKnown": false,
    "ratingReliable": true,
    "score": 35
  },
  "productHealth": {
    "conversionProxy": "DECENT",
    "socialProofScore": 28,
    "viralPotential": "LOW",
    "longevitySignal": "EVERGREEN",
    "ratingStrength": "STRONG",
    "ratingMomentum": "GAINING"
  },
  "pricingIntel": {
    "priceCategory": "MID",
    "estimatedRefundRisk": "LOW",
    "isPricingOptimal": true,
    "pricePerRating": 10.21,
    "optimalPriceRange": {
      "min": 19,
      "max": 59,
      "currency": "USD"
    }
  },
  "nicheAnalysis": {
    "nicheTag": "business",
    "nicheDemandScore": 61,
    "isNicheLeader": true,
    "priceVsNicheMedian": "+$20 above median",
    "pricePercentile": 72,
    "ratingVsNicheAvg": "+0.3 above avg"
  },
  "actionableInsights": {
    "buyerSignal": "WATCH",
    "creatorToWatch": false,
    "cloneOpportunity": "LOW",
    "whyThisMatters": "Growing engagement with 126 ratings -- worth monitoring for momentum."
  },
  "opportunityGrade": "B",
  "summary": "UNTESTED demand business product at $49. Rated 4.8 stars from 126 reviews. Data confidence: LOW. Grade: B -- evergreen appeal. Watch list.",
  "scrapedAt": "2026-06-21T16:00:00.000Z"
}
```

### How to read the scores

| Field | Meaning | Use it for |
|---|---|---|
| `interestScore` | Quick ranking score from rating quality, price fit, and available traction signals. | Sorting the whole dataset. |
| `opportunityGrade` | Letter grade derived from the interest score and evidence strength. | Shortlisting products. |
| `dataConfidence` | How much of the data behind the score is available. | Avoiding false confidence. |
| `ratingStrength` | How much review volume supports the rating. | Separating one lucky 5-star review from real proof. |
| `ratingMomentum` | Whether rating volume and average suggest traction. | Watchlist creation. |
| `nicheCompetition` | Density, median price, average rating, and entry barrier for the niche. | Picking markets to enter or avoid. |
| `buyerSignal` | Simple action label: `BUY_NOW`, `WATCH`, or `SKIP`. | Fast triage. |

### Run output

The actor writes:

1. A dataset with one item per product.
2. A key-value store record named `OUTPUT` with:
   - product count
   - niches searched
   - keywords searched
   - sort mode
   - filters used
   - grade distribution
   - top 10 products
   - generated timestamp

The Apify output schema also links directly to:

- ranked products dataset
- products overview table
- intelligence table
- run summary JSON

### Recommended workflows

#### Find product ideas

1. Pick 1-3 niches.
2. Use `sort: "top"`.
3. Start with `maxResultsPerNiche: 50`.
4. Sort by `interestScore` and `dataConfidence`.
5. Study the top products manually before building anything.

#### Build a pricing map

1. Search one niche at a time.
2. Export to CSV.
3. Group by `pricingTier`, `pricePercentile`, and `priceVsNicheMedian`.
4. Ignore one-off outliers unless they also have strong ratings.

#### Spot early opportunities

1. Use `sort: "newest"`.
2. Search buyer-intent keywords like `ai prompt`, `notion template`, `figma kit`, `automation`, `course`, or `bundle`.
3. Watch products with growing rating momentum.
4. Re-run weekly and compare outputs.

#### Build an affiliate shortlist

1. Filter to paid products.
2. Set `minRating` to `4`.
3. Look for clear niches, strong rating counts, and reasonable prices.
4. Review the creator and product page before outreach.

### Exports and integrations

You can download results as JSON, CSV, Excel, XML, or HTML from Apify.

You can also send the dataset to:

- Google Sheets
- Airtable
- Make
- Zapier
- Notion
- BI dashboards
- internal product research databases
- affiliate prospecting workflows

For API usage, call the default dataset endpoint after the run and pull `/items`.

### Limitations

- The actor scrapes public Gumroad Discover data only.
- It does not log into Gumroad.
- It does not scrape private customer data.
- Discover may omit sales counts, descriptions, and tags.
- Revenue estimates are only meaningful when sales data is available.
- Ratings are useful, but they are still a proxy. Verify any serious product decision manually.

### Responsible use

Use this for research, not lazy cloning.

Do not copy creators' products, impersonate sellers, scrape private data, or spam creators. The smart play is to study the market, find gaps, build a better offer, and cite your own proof.

# Actor input Schema

## `niches` (type: `array`):

Pick one or more Gumroad categories to research. Start with 1–3 niches for focused results.

## `keywords` (type: `array`):

Optional. Add buyer-intent keywords like notion template, ai prompt, fitness plan, figma kit. Leave empty to browse the whole niche.

## `sort` (type: `string`):

Top is best for proven winners. Newest is best for spotting fresh opportunities early.

## `maxResultsPerNiche` (type: `integer`):

How many products to collect from each niche. Use 50 for a quick scan; 100–200 for deeper market research.

## `minPrice` (type: `number`):

Filter out free or low-ticket products. Use 0 to include everything.

## `maxPrice` (type: `number`):

Filter out expensive products. Use 999 if you do not want a strict cap.

## `minRating` (type: `number`):

Optional quality filter from 0 to 5. Use 4+ when you only want strongly-rated products.

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

Optional Apify proxy settings. Leave default unless you know you need a specific proxy setup.

## Actor input object example

```json
{
  "niches": [
    "design",
    "programming"
  ],
  "keywords": [],
  "sort": "top",
  "maxResultsPerNiche": 50,
  "minPrice": 0,
  "maxPrice": 999,
  "minRating": 0,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `products` (type: `string`):

Ranked Gumroad products with market intelligence, pricing signals, ratings, creator details, and opportunity grades.

## `productsOverview` (type: `string`):

Apify Console dataset view optimized for browsing product names, creators, prices, ratings, opportunity grades, and URLs.

## `intelligenceView` (type: `string`):

Apify Console dataset view focused on market signals, product health, pricing intelligence, niche analysis, and actionable insights.

## `summary` (type: `string`):

JSON summary with product count, niches, top products, grade distribution, and generated timestamp.

# 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 = {};

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

# Run the Actor and wait for it to finish
run = client.actor("lokki/gumroad-product-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call lokki/gumroad-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lokki/gumroad-product-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6PrFwxetNSUJUjLA7/builds/arRYACjU4HfxK2pjM/openapi.json