# Gumroad Scraper - Products, Prices, Ratings & Creators (`scrapewise/gumroad-scraper`) Actor

Scrape Gumroad products by keyword, category, creator or URL: price in the seller's own currency, rating average and 1-5 star breakdown, product type, creator reputation and full description. No login, no browser. US$ 4 per 1,000 products; filtered-out rows are free.

- **URL**: https://apify.com/scrapewise/gumroad-scraper.md
- **Developed by:** [Scrapewise Data](https://apify.com/scrapewise) (community)
- **Categories:** E-commerce, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 1,000 product delivereds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Gumroad Scraper: Products, Prices, Ratings and Creators

**Gumroad scraper that collects products by keyword, by category, from a creator's storefront or from a list of product URLs, with the price in the seller's own currency, the rating average and its 1-to-5 star breakdown, the product type, the creator's reputation and the full description.**

For creators researching a niche before building a product, agencies sizing a market, and analysts tracking prices and ratings across the digital-product economy. AI agents can call it through the Apify MCP server.

### At a glance

| | This Actor | memo23/gumroad-scraper | muhammetakkurtt/gumroad-scraper |
|---|---|---|---|
| Price per 1,000 products, Free plan | **US$ 4.00** | US$ 5.00 | US$ 10.00 |
| Price per 1,000 products, Gold plan and above | **US$ 3.40** | see its page | see its page |
| Search, category, creator and product URL | yes | yes | category and URL |
| Filter by tag, file type, product type, price, rating | yes | yes | partial |
| Free-only, pay-what-you-want-only, verified-creator-only | yes | yes | no |
| Star breakdown (how many 1★ to 5★) | **yes** | see its page | see its page |
| Creator reputation (average, ratings, products on sale) | **yes** | see its page | see its page |
| Rows dropped by a filter | **never charged** | see its page | see its page |
| Users in the last 30 days | new | 14 | 16 |
| Run success, public runs in 30 days | new | 98% of 161 | 99% of 137 |

Competitor figures come from the public Apify API on 2026-09-20 and change every day. If you already use one of those and it fits, there is no reason to switch. This Actor exists for three things they do not all give: the star breakdown, the creator's reputation next to every product, and not being charged for rows a filter throws away.

### Quick start

1. Type a keyword, for example `notion template`.
2. Press **Start**.
3. Download the results as JSON, CSV or Excel.

Fifty products cost US$ 0.20 on the Free plan.

### Modes

| Mode | What it does | What to fill |
|---|---|---|
| **Search by keyword** | The same box as gumroad.com/discover | `searchQuery`, or several in `searchQueries` |
| **Browse a category** | Walks a whole category | `categories`, such as `business-and-money` |
| **All products of a creator** | Everything on a public storefront | `creators`, such as `productivesetups` |
| **Details of product URLs** | Full record for URLs you already have | `productUrls` |

You do not have to pick the mode by hand. Fill the field you have and the Actor follows it: product URLs win, then creators, then categories, then keywords.

### What data you get

Per product:

| Field | Example |
|---|---|
| `name`, `url`, `permalink`, `thumbnailUrl` | Headquarters Notion Productivity Template |
| `price`, `priceCents`, `currency` | 79.0, 7900, AUD |
| `ratingAverage`, `ratingCount` | 5.0 from 199 ratings |
| `ratingBreakdown` | `[0, 0, 1, 1, 98]`, percent of 1★ to 5★ |
| `nativeType`, `isRecurring`, `recurrence`, `durationInMonths` | digital, course, membership, bundle |
| `isPayWhatYouWant`, `isSalesLimited`, `quantityRemaining` | tells a real price from a suggested one |
| `sellerName`, `sellerProfileUrl`, `sellerIsVerified` | Productive Setups |
| `sellerRatingAverage`, `sellerRatingCount`, `sellerProductsCount` | 4.9 from 840 ratings, 37 products |
| `descriptionText`, `descriptionHtml`, `coverUrls` | the full sales page |
| `localPrice`, `localCurrency` | the converted price, marked as such |

**About currency, because it trips people up.** Gumroad converts prices to the currency of whoever is asking, so the same product can come back in USD, BRL or AUD depending on which proxy exit answered. `price` and `currency` in this Actor are always what the seller set. The converted figure is kept apart, in `localPrice` and `localCurrency`, so you know which is which.

`ratingBreakdown`, `sellerRatingAverage`, `sellerRatingCount`, `sellerProductsCount`, `descriptionText`, `descriptionHtml` and `coverUrls` need **Open each product page** on, which is the default. It costs one extra request per product.

### Filters

Applied by Gumroad, so they also cut what you pay for:

- `sort`: relevance, best sellers, hot and new, most reviewed, price up, price down, newest
- `minRating`: 1 to 5 stars
- `minPrice`, `maxPrice`: whole dollars
- `tags`: Gumroad tags, such as notion, productivity, planner
- `fileTypes`: pdf, zip, mp4, png, json, txt, docx, link

Applied after download, and **never charged for the rows they drop**:

- `nativeTypes`: digital, course, ebook, membership, bundle, physical and the rest
- `freeOnly`, `payWhatYouWantOnly`, `sellerVerifiedOnly`

**One caveat worth knowing:** Gumroad treats a pay-what-you-want product as starting at zero, so it matches any minimum price and can come back showing 0. The `isPayWhatYouWant` field tells those apart. Gumroad's own free-only filter was tested on 2026-09-20 and the site ignores it, which is why `freeOnly` here is applied on our side.

### Use cases

#### Research a niche before building a product

Search your niche sorted by most reviewed, and read `ratingCount` and `ratingBreakdown`. A product with 199 ratings and 98% at five stars tells you what buyers already accept, and the price they paid for it.

#### Size a market

Walk a whole category and add up prices, types and rating counts. `sellerProductsCount` shows whether a niche is a few big creators or a long tail.

#### Track competitors

Point the creator mode at the storefronts you follow and run it weekly. Price changes, new products and rating growth all show up.

#### Price your own product

Filter your niche by rating and price range, and you have the real distribution instead of a guess.

#### AI agents

The Actor is on the Apify MCP server, so an agent can call it with a keyword and get structured products back.

### Pricing

Pay per event: **US$ 4.00 per 1,000 products delivered** on the Free plan, going down to US$ 3.40 on Gold and above. There is no start fee.

You are charged per product that reaches the dataset. You are **not** charged for:

- rows carrying an `errorCode` (product removed, creator not found, empty search)
- products dropped by `nativeTypes`, `freeOnly`, `payWhatYouWantOnly` or `sellerVerifiedOnly`
- duplicates, which are removed inside the run before charging

| What you collect | Cost, Free plan |
|---|---|
| 50 products | US$ 0.20 |
| 1,000 products | US$ 4.00 |
| 10,000 products | US$ 40.00 |

### Speed and reliability

No browser is used. Gumroad serves its whole page state as JSON inside the HTML, so one request brings 36 products. A run of 3 products without product pages took **1 request**; with product pages, one extra request each.

Blocked requests are retried on a new proxy IP, up to three times. If the block does not clear, the run ends with a row carrying `errorCode: BLOCKED` instead of failing silently, and that row is free.

Bad input never kills the run: a creator that does not exist, a dead product URL, a search with no match and an unknown category each come back as one row with an `errorCode`, and the run still finishes green.

### Use it from code, no-code tools and AI agents

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("scrapewise/gumroad-scraper").call(run_input={
    "mode": "search",
    "searchQuery": "notion template",
    "minRating": 4,
    "sort": "most_reviewed",
    "maxItems": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["price"], item["currency"], item["ratingAverage"])
```

#### Node.js

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('scrapewise/gumroad-scraper').call({
    mode: 'creator',
    creators: ['productivesetups'],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### HTTP API

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapewise~gumroad-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H 'Content-Type: application/json' \
  -d '{"mode":"search","searchQuery":"notion template","maxItems":50}'
```

#### n8n, Make, Zapier and Google Sheets

Use the Apify integration and pick this Actor, or call the HTTP API above. The dataset also exports straight to CSV and Excel.

#### AI agents (MCP)

Point your agent at the Apify MCP server and it can run this Actor by name.

### Is this legal?

The Actor reads the same public pages any visitor sees on gumroad.com, without logging in and without touching anything behind a paywall. It collects product listings, prices, ratings and public creator profiles. It does not collect buyer data, purchase records or anything private. You are responsible for what you do with the data, including any personal data in a public profile, under the rules that apply to you.

### FAQ

**Do I need a Gumroad account?** No. Everything comes from public product and profile pages.

**Do failed items cost anything?** No. A removed product, a seller with no public products or a
page that refused the request comes back as a free row with a stable `errorCode`.

**Can I follow a seller's whole catalogue?** Yes, pass the seller URL and the Actor walks the
public product list, up to the limit you set.

**How fresh are the numbers?** Ratings and sales counts are read live from the page at run time,
so they are as fresh as what a visitor sees.

# Actor input Schema

## `mode` (type: `string`):

What the run does. If you leave it on 'search' but fill another field, the Actor uses the field you filled: product URLs win, then creators, then categories.

## `searchQuery` (type: `string`):

Keyword for 'search' mode, the same box as gumroad.com/discover. Example: notion template.

## `searchQueries` (type: `array`):

Extra keywords for 'search' mode. Each keyword returns up to 'Max products per source'; duplicates across keywords are removed and charged once.

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

For 'category' mode: the category slug as it appears in the URL, such as business-and-money, design, software-development, self-improvement. A full URL like https://gumroad.com/business-and-money also works.

## `creators` (type: `array`):

For 'creator' mode: the creator subdomain (productivesetups), the full domain (productivesetups.gumroad.com) or the profile URL. Returns the products on their public storefront.

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

For 'product' mode: product URLs such as https://creator.gumroad.com/l/permalink. A bare permalink also works. These always come with description, star breakdown and creator reputation.

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

Order of the results in 'search' and 'category' modes, the same options Gumroad offers on the page.

## `minRating` (type: `integer`):

Keeps only products rated at or above this many stars. Leave empty for all.

## `minPrice` (type: `integer`):

Lowest price to include, in whole dollars. 0 keeps free products. Note: Gumroad treats 'pay what you want' products as starting at zero, so they match any minimum and can come back showing 0. Use the isPayWhatYouWant field in the output to tell them apart.

## `maxPrice` (type: `integer`):

Highest price to include, in whole dollars. Same caveat as 'Minimum price' for 'pay what you want' products.

## `tags` (type: `array`):

Keeps only products carrying these Gumroad tags, such as notion, productivity, planner. Applied by Gumroad itself. The tags available for a search show up in its own results, so start broad and narrow down.

## `fileTypes` (type: `array`):

Keeps only products delivering these file types: pdf, zip, mp4, png, json, txt, docx, link. Applied by Gumroad itself.

## `nativeTypes` (type: `array`):

Keeps only these product types, as Gumroad labels them: digital, course, ebook, membership, bundle, physical, coffee, newsletter, podcast, audiobook, physical\_good. Applied after download, so it costs requests but never charges you for the rows it drops.

## `freeOnly` (type: `boolean`):

Keeps only products priced at zero. Gumroad's own free filter was tested and is ignored by the site, so this one is applied here, after download.

## `payWhatYouWantOnly` (type: `boolean`):

Keeps only products where the buyer names the price.

## `sellerVerifiedOnly` (type: `boolean`):

Keeps only products from creators Gumroad marks as verified.

## `includeDetails` (type: `boolean`):

Adds the full description, the 1-to-5 star breakdown, every cover image and the creator's reputation (average, number of ratings, how many products they sell). Costs one extra request per product, so it is slower.

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

Hard limit for the whole run. This is what you pay for: US$ 4 per 1,000 products delivered.

## `maxItemsPerSource` (type: `integer`):

Limit per keyword, category or creator, so one busy source does not eat the whole run. Defaults to 'Max products'.

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

Apify datacenter proxy is the default and works for Gumroad. Blocked requests are retried on a new IP.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "notion template",
  "categories": [
    "business-and-money"
  ],
  "creators": [
    "productivesetups"
  ],
  "productUrls": [
    "https://productivesetups.gumroad.com/l/headquarters"
  ],
  "sort": "relevance",
  "freeOnly": false,
  "payWhatYouWantOnly": false,
  "sellerVerifiedOnly": false,
  "includeDetails": true,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `resultsCsv` (type: `string`):

No description

# 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 = {
    "mode": "search",
    "searchQuery": "notion template",
    "categories": [
        "business-and-money"
    ],
    "creators": [
        "productivesetups"
    ],
    "productUrls": [
        "https://productivesetups.gumroad.com/l/headquarters"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapewise/gumroad-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 = {
    "mode": "search",
    "searchQuery": "notion template",
    "categories": ["business-and-money"],
    "creators": ["productivesetups"],
    "productUrls": ["https://productivesetups.gumroad.com/l/headquarters"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapewise/gumroad-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 '{
  "mode": "search",
  "searchQuery": "notion template",
  "categories": [
    "business-and-money"
  ],
  "creators": [
    "productivesetups"
  ],
  "productUrls": [
    "https://productivesetups.gumroad.com/l/headquarters"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapewise/gumroad-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapewise/gumroad-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/QJcWga3s8BQdVYzK7/builds/cx2z8T1XkE6pFG614/openapi.json