# Gumroad Products Scraper (`zerobreak/gumroad-products-scraper`) Actor

Scrapes Gumroad products from any category, search, or discover URL and returns all product details including name, price, seller, ratings, thumbnail, and plain-text descriptions.

- **URL**: https://apify.com/zerobreak/gumroad-products-scraper.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Categories:** Developer tools, Integrations, Other
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.90/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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

### Gumroad Products Scraper 

A powerful and flexible tool to **scrape Gumroad product data**. Ideal for **market research, competitor tracking, price monitoring, or lead generation**, this scraper produces clean, structured data in JSON, CSV, or Excel formats.

This actor can run on **Apify Cloud**, **AWS Lambda**, or any HTTP-based automation workflow.

---

###  Key Features

- **Multi-Mode Search** – Scrape products via:
  - Direct URLs
  - Keyword queries
  - Advanced category & filter search
- **Deep Product Metadata** – Capture:
  - Name, price, and description
  - Ratings & reviews
  - Seller information
  - Product images & files
- **Automatic URL Classification** – Detect whether a URL is a product, collection, or profile
- **Pagination & Limit Control** – Use `pages` and `per_page` to control scraping volume
- **Retry & Error Handling** – Automatic retries for failed requests
- **Secure API Access** – Supports API key authentication
- **Structured Output** – JSON, CSV, or Excel-ready dataset

---

###  Quick Start

#### 1️⃣ Choose Your Input Method

You can scrape via **search queries**, **filter options**, or **direct URLs**.

##### Search Using Queries

```json
{
  "modes": ["query"],
  "query": "education"
}
````

##### Filter Search

```json
{
  "modes": ["filter"],
  "tags": ["design", "car"],
  "filetypes": ["PDF", "PNG"],
  "rating": 4
}
```

##### Scrape Using Direct URLs

```json
{
  "modes": ["url"],
  "urls": [
    "https://gumroad.com/discover?query=car+drawing"
  ]
}
```

You can combine multiple modes in one run:

```json
{
  "modes": ["query", "filter", "url"]
}
```

***

#### 2️⃣ Configure Optional Parameters

```json
{
  "pages": 2,
  "per_page": 18
}
```

***

#### 3️⃣ Run the Actor

- Save your input configuration
- Click **Run** in Apify Console
- Monitor logs for progress and errors

***

#### 4️⃣ Access Results

- Scraped data is saved in **Apify Dataset**
- Each query, filter, or URL produces separate dataset items
- Output is in **structured JSON** for analytics, CSV, or Excel

***

### Output Examples

#### Query or Filter Search Item

```json
 [{
  'id': '0lmlMQcCSJhDWYGEynLWRA==',
  'name': 'Winterpaw Feline ~ VRChat + VTuber',
  'permalink': 'tjhbd',
  'page_url': 'https://juliawinterpaw.gumroad.com/l/Feline?layout=discover&recommended_by=search',
  'price_cents': 0,
  'currency': 'usd',
  'seller_id': '9728859314363',
  'seller_name': 'Julia Winterpaw',
  'avatar_url': 'https://public-files.gumroad.com/f37i3dj748y8r76pt6q6i7ygmwl4',
  'profile_url': 'https://juliawinterpaw.gumroad.com?recommended_by=search',
  'thumbnail_url': 'https://public-files.gumroad.com/ocj0gnerjlgnecv9g07q15pw7wes',
  'ratings_count': 80,
  'ratings_average': 5.0,
  'native_type': 'digital',
  'recurrence': None,
  'description': "Introducing the Winterpaw Feline!This is the most advanced Winterpaw avatar we've ever made. Afte..."
  },]
```

#### URL Result Item

```json
[{
        "id": "c1a2b3d4e5",
        "name": "Car Sketching Guide",
        "permalink": "car-sketching-guide",
        "page_url": "https://gumroad.com/l/car-sketching-guide",
        "price_cents": 1500,
        "currency": "usd",
        "seller_id": "s123456",
        "seller_name": "John Doe",
        "avatar_url": "https://gumroad.com/avatar/johndoe.jpg",
        "profile_url": "https://gumroad.com/johndoe",
        "thumbnail_url": "https://gumroad.com/thumbnail/car-sketch.jpg",
        "ratings_count": 12,
        "ratings_average": 4.8,
        "native_type": "digital",
        "recurrence": None,
        "description": "Step-by-step car drawing guide for beginners."
    },]
```

***

### How It Works

1. Reads input from Apify (`modes`, `query`, `tags`, `urls`, etc.)
2. Executes the selected scraping mode(s)
3. Automatically classifies URLs as product, collection, or profile
4. Fetches product data from Gumroad backend
5. Normalizes responses and pushes to dataset

***

### Error Handling

- Automatic retries on temporary failures
- Unsupported URLs are safely skipped
- Clear logging for debugging

***

### Use Cases

- Market & trend research
- Competitor price tracking
- Lead generation
- Analytics dashboards
- Product discovery & aggregation

***

### Support

- Fully extendable and customizable
- Works on **Apify Cloud**, **AWS Lambda**, or any HTTP API workflow

# Actor input Schema

## `modes` (type: `array`):

Select one or more search modes to use

## `queries` (type: `array`):

List of search queries (for 'query' mode)

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

List of Gumroad URLs to scrape (for 'url' mode)

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

Filter by tags (for 'filter' mode)

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

Filter by specific file extensions (e.g., pdf, zip)

## `category` (type: `string`):

Select a specific Gumroad category to filter results

## `rating` (type: `integer`):

Filter products by a minimum star rating (1-5)

## `priceMin` (type: `number`):

The lowest price to include in results

## `priceMax` (type: `number`):

The highest price to include in results

## `filterQuery` (type: `string`):

A search string to refine the results within the filter mode

## `limit` (type: `integer`):

Maximum number of total products to return

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

How to order the products in the final output

## `pages` (type: `integer`):

The number of search result pages to browse through

## `perPage` (type: `integer`):

Number of items to fetch per request (default is 24)

## Actor input object example

```json
{
  "modes": [
    "query",
    "filter",
    "url"
  ],
  "queries": [
    "graphic design",
    "stock photos",
    "music beats"
  ],
  "urls": [
    "https://gumroad.com/discover?query=Car+Drawing&sort=newest"
  ],
  "tags": [
    "art",
    "design",
    "photography"
  ],
  "fileTypes": [
    "pdf",
    "zip",
    "mp3"
  ],
  "category": "design",
  "rating": 4,
  "priceMin": 5,
  "priceMax": 50,
  "filterQuery": "modern aesthetic",
  "limit": 50,
  "sort": "highest_rated",
  "pages": 3,
  "perPage": 24
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "graphic design",
        "stock photos",
        "music beats"
    ],
    "urls": [
        "https://gumroad.com/discover?query=Car+Drawing&sort=newest"
    ],
    "tags": [
        "art",
        "design",
        "photography"
    ],
    "fileTypes": [
        "pdf",
        "zip",
        "mp3"
    ],
    "filterQuery": "modern aesthetic"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/gumroad-products-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 = {
    "queries": [
        "graphic design",
        "stock photos",
        "music beats",
    ],
    "urls": ["https://gumroad.com/discover?query=Car+Drawing&sort=newest"],
    "tags": [
        "art",
        "design",
        "photography",
    ],
    "fileTypes": [
        "pdf",
        "zip",
        "mp3",
    ],
    "filterQuery": "modern aesthetic",
}

# Run the Actor and wait for it to finish
run = client.actor("zerobreak/gumroad-products-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 '{
  "queries": [
    "graphic design",
    "stock photos",
    "music beats"
  ],
  "urls": [
    "https://gumroad.com/discover?query=Car+Drawing&sort=newest"
  ],
  "tags": [
    "art",
    "design",
    "photography"
  ],
  "fileTypes": [
    "pdf",
    "zip",
    "mp3"
  ],
  "filterQuery": "modern aesthetic"
}' |
apify call zerobreak/gumroad-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumroad Products Scraper",
        "description": "Scrapes Gumroad products from any category, search, or discover URL and returns all product details including name, price, seller, ratings, thumbnail, and plain-text descriptions.",
        "version": "0.0",
        "x-build-id": "hzYi2nU9dnYUejcgt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zerobreak~gumroad-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zerobreak-gumroad-products-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/zerobreak~gumroad-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zerobreak-gumroad-products-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/zerobreak~gumroad-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zerobreak-gumroad-products-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",
                "required": [
                    "modes"
                ],
                "properties": {
                    "modes": {
                        "title": "Search Modes",
                        "minItems": 1,
                        "maxItems": 3,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select one or more search modes to use",
                        "items": {
                            "type": "string",
                            "enum": [
                                "query",
                                "filter",
                                "url"
                            ],
                            "enumTitles": [
                                "Query Search",
                                "Filter Search",
                                "URL Search"
                            ]
                        },
                        "default": [
                            "query",
                            "filter",
                            "url"
                        ]
                    },
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "List of search queries (for 'query' mode)",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "graphic design",
                            "stock photos",
                            "music beats"
                        ]
                    },
                    "urls": {
                        "title": "Gumroad URLs",
                        "type": "array",
                        "description": "List of Gumroad URLs to scrape (for 'url' mode)",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://gumroad.com/l/example-product-1",
                            "https://gumroad.com/l/example-product-2"
                        ]
                    },
                    "tags": {
                        "title": "Tags Filter",
                        "type": "array",
                        "description": "Filter by tags (for 'filter' mode)",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "art",
                            "design",
                            "photography"
                        ]
                    },
                    "fileTypes": {
                        "title": "File Types Filter",
                        "type": "array",
                        "description": "Filter by specific file extensions (e.g., pdf, zip)",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "pdf",
                            "zip",
                            "mp3"
                        ]
                    },
                    "category": {
                        "title": "Category Filter",
                        "enum": [
                            "",
                            "art",
                            "design",
                            "software",
                            "writing",
                            "music",
                            "photography",
                            "business",
                            "other"
                        ],
                        "type": "string",
                        "description": "Select a specific Gumroad category to filter results",
                        "default": "design"
                    },
                    "rating": {
                        "title": "Minimum Rating Filter",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Filter products by a minimum star rating (1-5)",
                        "default": 4
                    },
                    "priceMin": {
                        "title": "Minimum Price Filter ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "The lowest price to include in results",
                        "default": 5
                    },
                    "priceMax": {
                        "title": "Maximum Price Filter ($)",
                        "minimum": 0,
                        "type": "number",
                        "description": "The highest price to include in results",
                        "default": 50
                    },
                    "filterQuery": {
                        "title": "Additional Filter Query",
                        "type": "string",
                        "description": "A search string to refine the results within the filter mode",
                        "default": "modern aesthetic"
                    },
                    "limit": {
                        "title": "Result Limit",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of total products to return",
                        "default": 50
                    },
                    "sort": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevance",
                            "newest",
                            "highest_rated",
                            "most_popular",
                            "price_low_high",
                            "price_high_low"
                        ],
                        "type": "string",
                        "description": "How to order the products in the final output",
                        "default": "highest_rated"
                    },
                    "pages": {
                        "title": "Pages to Scrape",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "The number of search result pages to browse through",
                        "default": 3
                    },
                    "perPage": {
                        "title": "Results Per Page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of items to fetch per request (default is 24)",
                        "default": 24
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
