# Gumroad Products Scraper (`automation-lab/gumroad-product-catalog-scraper`) Actor

Export public Gumroad Discover product cards with seller profiles, prices, currencies, rating summaries, thumbnails, product types, and URLs for catalog research and monitoring.

- **URL**: https://apify.com/automation-lab/gumroad-product-catalog-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 item extracteds

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 Products Scraper

Export public **Gumroad products** from Gumroad Discover into a structured dataset.
Each row contains product identity, seller profile, listed price and currency,
rating summary, thumbnail, product type, and canonical URL.

Use the Actor for repeatable catalog snapshots, niche research, price comparisons,
and product discovery without manually copying cards from Discover.
It uses Gumroad's public server-rendered Discover data and does not require a login.

### What does Gumroad Products Scraper do?

The Actor accepts one or more search queries or filtered Gumroad Discover URLs.
It paginates public results, normalizes each card, removes duplicate products,
applies optional rating and product-type filters, and saves accepted products to
the default Apify dataset.

It is intentionally focused on public catalog cards.
It does not claim to extract purchases, private customer data, written reviews,
creator email addresses, sales counts, or files sold by creators.

### Who is this Gumroad product data for?

- **Catalog analysts** tracking products and sellers in a digital-product niche.
- **Creators** comparing public pricing, ratings, and product positioning.
- **Market researchers** building a reproducible catalog snapshot.
- **Agencies** discovering public creator profiles and product URLs.
- **Data teams** loading Gumroad Discover records into a warehouse or dashboard.
- **Developers** integrating public catalog discovery into an existing workflow.

Choose this Actor when product-card data is the unit you need.
A product-detail or review-specific workflow requires a different data source and
is outside this Actor's scope.

### Why use this Actor?

- Search several real Gumroad niches in one run.
- Start from a public Discover URL with Gumroad filters already applied.
- Collect up to 10,000 products per run with duplicate removal.
- Filter by minimum average rating or exact public product type.
- Receive stable, typed field names instead of page markup.
- Keep the product URL and source URL for traceability.
- Pay only for the run start and product rows saved.
- Run locally, from the Apify API, on a schedule, or through MCP.

The Actor fetches HTML only; it does not download product thumbnails or paid
product files.

### What Gumroad product fields are extracted?

| Field | Description |
| --- | --- |
| `productId` | Gumroad product identifier when exposed |
| `permalink` | Product permalink slug |
| `title` | Product title on the Discover card |
| `productUrl` | Clean public product URL |
| `sellerName` | Public seller display name |
| `sellerProfileUrl` | Clean public seller profile URL |
| `sellerVerified` | Whether Gumroad marks the seller as verified |
| `price` | Listed price in the currency's major unit |
| `priceCents` | Raw listed price in the currency's minor unit |
| `currency` | Uppercase currency code |
| `ratingAverage` | Public average rating, or `null` when unrated |
| `ratingCount` | Number of ratings in the public summary |
| `thumbnailUrl` | Product-card thumbnail URL |
| `productType` | Gumroad native product type when exposed |
| `isPayWhatYouWant` | Whether pay-what-you-want is enabled |
| `recurrence` | Recurring billing interval when exposed |
| `query` | Search query associated with the result |
| `sourceUrl` | Discover URL used to find the product |
| `scrapedAt` | UTC extraction timestamp |

Fields may be `null` when Gumroad does not expose them on a card.
The dataset schema permits extra upstream fields for forward compatibility, but
the Actor currently emits only the documented normalized fields.

### How to scrape Gumroad products

1. Open the Actor in Apify Console.
2. Enter a real query such as `procreate brushes` or `notion templates`.
3. Optionally add Gumroad Discover URLs with filters already selected.
4. Set the maximum number of products.
5. Optionally set a minimum rating or product types.
6. Click **Start**.
7. Open the **Dataset** tab to inspect, download, or integrate the results.

Start with 10–50 products while validating a niche.
Increase the limit when the output matches the catalog job you need.

### Input parameters

#### `searchQueries`

A list of keyword searches sent to public Gumroad Discover.
Blank query values are ignored.
Examples include `procreate brushes`, `vrchat avatar`, and `notion templates`.

#### `startUrls`

Optional URLs under `https://gumroad.com/discover`.
The Actor preserves their query parameters and controls pagination itself.
Other domains, seller storefront URLs, and direct product URLs fail validation.

#### `maxItems`

Maximum accepted products across all inputs after duplicate removal.
The default is 100; valid values are 1 through 10,000.
Filters may cause the Actor to inspect more cards than it saves.

#### `minRating`

Optional number from 0 through 5.
Products without a public average rating are treated as zero for this filter.

#### `productTypes`

Optional exact type values such as `digital`, `ebook`, or `course`.
Values are matched case-insensitively against the type Gumroad exposes.
Run once without this filter if you need to inspect current source values.

### Example input

```json
{
  "searchQueries": [
    "notion templates",
    "notion finance template"
  ],
  "minRating": 4,
  "maxItems": 50
}
```

A URL-driven run is also supported:

```json
{
  "startUrls": [
    { "url": "https://gumroad.com/discover?query=vrchat%20avatar" }
  ],
  "maxItems": 20
}
```

### Example output

A current public Discover card produces a row shaped like this:

```json
{
  "productId": "QWJjREVGR0hJSktMTU5PUA==",
  "permalink": "sample-brush-pack",
  "title": "Sample Procreate Brush Pack",
  "productUrl": "https://samplecreator.gumroad.com/l/sample-brush-pack",
  "sellerName": "Sample Creator",
  "sellerProfileUrl": "https://samplecreator.gumroad.com/",
  "sellerVerified": true,
  "price": 12.5,
  "priceCents": 1250,
  "currency": "USD",
  "ratingAverage": 4.8,
  "ratingCount": 42,
  "thumbnailUrl": "https://public-files.gumroad.com/sample-image",
  "productType": "digital",
  "isPayWhatYouWant": false,
  "recurrence": null,
  "query": "procreate brushes",
  "sourceUrl": "https://gumroad.com/discover?query=procreate%20brushes",
  "scrapedAt": "2026-08-27T06:00:00.000Z"
}
```

The sample identity is anonymized.
Actual rows contain current public Gumroad values.

### How much does it cost to scrape Gumroad products?

This is a pay-per-event Actor.
A run currently has a **$0.03 start fee** plus a tiered fee for each
item saved.
At the current BRONZE tier, the item fee is **$0.003 per item**.
Higher usage tiers have lower per-item prices; Apify applies the tier for the
customer's plan.

BRONZE examples use the same active prices:

| Items saved | Pricing calculation |
| ---: | --- |
| 10 | one $0.03 start event plus 10 item events at $0.003 each |
| 100 | one $0.03 start event plus 100 item events at $0.003 each |
| 1,000 | one $0.03 start event plus 1,000 item events at $0.003 each |

Only accepted rows are charged as item events.
Rejected filters, duplicate cards, failed pages, and empty results do not create
item charges.
Apify platform pricing shown on the Actor page is authoritative.

### Catalog monitoring workflow

Use an Apify schedule to run the same input daily or weekly.
Export each dataset to your database with `productId` or `productUrl` as the key.
Compare `price`, `currency`, `ratingAverage`, `ratingCount`, and seller fields
between snapshots in your own pipeline.

The Actor produces timestamped snapshots.
It does not retain history, calculate differences, or send alerts by itself.
This boundary keeps the output easy to connect to any monitoring stack.

### Spreadsheet and data-pipeline integrations

- Download the dataset as JSON, CSV, Excel, XML, or RSS in Apify Console.
- Connect Apify to Google Sheets for a lightweight catalog table.
- Send run results through a webhook after completion.
- Read dataset items from Python or JavaScript.
- Load records into BigQuery, Snowflake, PostgreSQL, or another warehouse.
- Use Make, Zapier, or n8n to trigger downstream review workflows.

Use `productId` when available and fall back to `productUrl` for de-duplication.
Keep `scrapedAt` when snapshots must be compared over time.

### Run with the Apify API

Replace `APIFY_TOKEN` with your Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~gumroad-product-catalog-scraper/runs?token=APIFY_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["procreate brushes"],"maxItems":20}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/gumroad-product-catalog-scraper').call({
  searchQueries: ['procreate brushes'],
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="APIFY_TOKEN")
run = client.actor("automation-lab/gumroad-product-catalog-scraper").call(
    run_input={"searchQueries": ["procreate brushes"], "maxItems": 20}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Avoid placing tokens directly in source control.
Use environment variables or your platform's secret manager.

### Use Gumroad Products Scraper with MCP

Add the Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/gumroad-product-catalog-scraper"
```

#### Claude Desktop

Use this remote MCP configuration in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/gumroad-product-catalog-scraper"
    }
  }
}
```

#### Cursor

Add the same `mcpServers.apify.url` value in Cursor's MCP settings.

#### VS Code

Add the same remote server URL through your VS Code MCP extension or settings.

Example prompts:

- "Find 20 public Gumroad Procreate brush products and summarize price ranges."
- "Export highly rated Gumroad Notion templates as a table."
- "Create a Gumroad VRChat avatar catalog with sellers, ratings, and URLs."

MCP tool availability depends on your Apify authentication and client setup.

### Reliability, pagination, and limits

Gumroad currently returns structured product cards in server-rendered Inertia
data, with 36 cards per Discover page.
The Actor recognizes that data shape and paginates with Gumroad's public offset.

Temporary network errors, HTTP 429 responses, and server errors receive bounded
retries with backoff.
A permanent non-200 response or an unrecognized page shape fails the run rather
than silently returning a misleading empty dataset.

The Actor uses direct HTTP without a proxy or browser.
If Gumroad changes its public markup or access policy, a code update may be
required.
Naturally sparse searches can return fewer products than `maxItems`.

### Tips for better results

- Use specific buyer phrases rather than a single broad word.
- Run separate queries when niches have different vocabulary.
- Begin without `productTypes` to observe Gumroad's current type values.
- Remember that prices are expressed in each row's own `currency`.
- Treat a null rating as unavailable, not as a negative customer review.
- Schedule consistent input and timing for comparable catalog snapshots.
- Keep limits proportional to the number of records you actually need.
- Inspect logs when a source query unexpectedly returns no accepted records.

### Responsible and legal use

This Actor accesses public Gumroad Discover pages without logging in.
You are responsible for ensuring your collection and use comply with Gumroad's
terms, applicable laws, database rights, privacy rules, and contractual duties.

Do not use output for harassment, unlawful profiling, spam, or attempts to
access paid files or private customer information.
Collect only what is necessary for a legitimate purpose, apply appropriate
retention controls, and honor valid deletion or correction obligations.
This documentation is not legal advice.

### Troubleshooting

#### Why did the run reject my URL?

Only public `https://gumroad.com/discover` URLs are accepted in `startUrls`.
Use `searchQueries` for keyword discovery.
Seller storefront and direct product pages are not part of this catalog Actor.

#### Why are there fewer rows than requested?

The search may be sparse, filters may reject cards, or the same product may
appear under more than one input.
The Actor de-duplicates products and charges only rows it saves.

#### Why is `ratingAverage` null?

Gumroad does not expose a positive rating average for every product card.
Use `ratingCount` and retain null as "not available."

#### Why did the run fail instead of returning zero rows?

An invalid source URL, unexpected HTTP response, or changed Gumroad data shape
is operational failure, not proof that a catalog contains zero products.
Inspect the run log and retry later if Gumroad returned a temporary error.

### FAQ

#### Does the Actor download Gumroad products?

No.
It exports public metadata cards only and never downloads the files being sold.

### Related Automation Lab Actors

- [Flipkart Product Listings Scraper](https://apify.com/automation-lab/flipkart-product-listings-scraper) for public Flipkart search and category catalog records.
- [Shopee Product Details Scraper](https://apify.com/automation-lab/shopee-product-details-scraper) for supplied public Shopee product detail pages.
- [Naver Shopping Product Scraper](https://apify.com/automation-lab/naver-shopping-product-scraper) for Korean shopping search and price monitoring.

These Actors cover different sources.
Choose the source that matches the catalog you are authorized to analyze.

### Support

For reproducible help, include the run URL, sanitized input, expected result,
and the first relevant error from the log.
Do not post API tokens, account credentials, paid Gumroad content, or personal
data in a public support message.

# Actor input Schema

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

Keywords to search on Gumroad Discover, such as procreate brushes or notion templates.

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

Optional public gumroad.com/discover URLs with Gumroad filters already applied.

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

Maximum number of unique product records saved across all queries and URLs.

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

Keep products at or above this average rating. Products without a rating are treated as zero.

## `productTypes` (type: `array`):

Optional exact Gumroad product types to keep, such as ebook, course, or digital.

## Actor input object example

```json
{
  "searchQueries": [
    "procreate brushes"
  ],
  "startUrls": [],
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Product identity, seller, price, rating, thumbnail, type, URL, source, and extraction timestamp fields.

# 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 = {
    "searchQueries": [
        "procreate brushes"
    ],
    "startUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gumroad-product-catalog-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 = {
    "searchQueries": ["procreate brushes"],
    "startUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/gumroad-product-catalog-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 '{
  "searchQueries": [
    "procreate brushes"
  ],
  "startUrls": [],
  "maxItems": 20
}' |
apify call automation-lab/gumroad-product-catalog-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/gumroad-product-catalog-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/fUWOZkXMi3Yn0k1cE/builds/MdeeRoTMgCbkkjwYK/openapi.json