# Gumroad Scraper — Products, Sellers, Reviews & Creator Emails (`memo23/gumroad-scraper`) Actor

Gumroad scraper — products by keyword, tag, category, whole seller storefronts or product URLs. Price/rating/type filters, sales counts, rating histograms, written reviews, creator leads with contact emails, monitor mode for new & changed products. Pure HTTP, JSON or CSV out.

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

## Pricing

from $5.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Scraper

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/gumroad-logo.png" alt="Gumroad Scraper" width="200" />
</p>

The fastest way to turn Gumroad into structured product, seller, and review data.
Start from any Gumroad entry point — search keywords, tags, discover categories, whole seller storefronts, or direct product URLs — and get clean rows ready for market research, price tracking, and creator lead generation.

Pure HTTP on Gumroad's own JSON endpoints. No browser, no CAPTCHA solver.

| Input you give it | Rows you get back |
|---|---|
| Search keywords (`notion template`, `ai course`) | Product rows from the discover catalog |
| Tags & category paths (`design`, `3d/vrchat`) | Product rows from that niche |
| Seller storefront URLs (`https://seller.gumroad.com`) | Every product of that creator, all sections, de-duplicated |
| Direct product URLs (`…/l/permalink`) | Fully detailed product rows |
| `includeSellerRecord` / `enrichEmails` toggles | One `creator` record per unique seller — with contact emails where discoverable |

### Why Use This Scraper?

- **Five entry points in one actor** — keyword search, tag browse, category browse, seller storefronts, and direct product URLs. Mix them in a single run.
- **Real filters, applied server-side** — min/max price (USD), minimum rating, product types, file types. Filtered results are re-checked exactly before output, so a $20 floor means a $20 floor.
- **Whole storefronts, done right** — profile sections are parsed from Gumroad's embedded JSON, paginated past the visible first 9 products, and de-duplicated across overlapping sections.
- **Sales counts & rating histograms** — detail mode adds `salesCount` (when the seller shows it), the full 1–5★ rating breakdown, variants/tiers with per-option pricing, and membership billing cycles.
- **Written reviews inline** — review text, star rating, reviewer name, and seller replies attached to each product row. No second actor to pay for.
- **Creator leads with contact emails** — one record per unique seller with bio, external website, Twitter/X handle, and (opt-in) discovered contact emails plus payment-stack signals.
- **Monitor mode** — schedule the same input and only get rows that are *new or changed* since the last run: price moves, fresh sales, new ratings.
- **Cheap by default** — card mode returns 20+ fields per product with no extra requests; detail, reviews, and creator fetches are strictly opt-in.

### Overview

This actor is built for anyone who needs structured data about the digital-product economy: which products sell, at what price, with what ratings, and who makes them.

Every dataset row has a `type` field:

- `type: "product"` — one Gumroad product (the default row).
- `type: "creator"` — one unique seller (only when `includeSellerRecord` or `enrichEmails` is on). Creator records do not count toward `maxItems`.

Products come from Gumroad's discover/search JSON API and product-page JSON — the same endpoints the site itself uses — which keeps rows complete and stable.

### Supported Inputs

| Input | Example | Notes |
|---|---|---|
| Search keywords | `notion template`, `lightroom presets` | Searches the whole discover catalog |
| Tags | `notion`, `photography`, `procreate` | Same catalog, tag-scoped |
| Category paths | `design`, `3d/vrchat`, `business-and-money`, `software-development` | Use the path as it appears in `gumroad.com/discover` URLs |
| Seller storefronts | `https://liindy.gumroad.com` | Subdomain **and** custom-domain Gumroad stores |
| Product URLs | `https://seller.gumroad.com/l/permalink`, `https://gumroad.com/l/permalink` | Always fully detailed; filters don't apply to explicit URLs |

**Not supported:** checkout/receipt pages, the logged-in library, affiliate dashboards, or any content behind login.

### Use Cases

| Who | What they pull |
|---|---|
| Indie hackers & creators | Price maps and best-seller lists for a niche before building their own product |
| Market researchers | Category-level demand signals: ratings volume, sales counts, price distribution |
| Lead-gen & agencies | Creator records with external websites, emails, and payment-stack signals |
| Competitor watchers | Monitor mode diffs on a rival's storefront: new launches, price changes |
| Review analysts | Written review text at scale for sentiment and product-gap analysis |

### How It Works

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-gumroad.png" alt="How the Gumroad Scraper works" width="800" />
</p>

1. **Point it at Gumroad** — any mix of keywords, tags, categories, storefront URLs, and product URLs.
2. **Server-side filtering** — price window, minimum rating, and file types are pushed into Gumroad's own search API, so you don't pay for rows you'll throw away.
3. **Fetch & normalize** — product cards are normalized into flat rows; detail mode adds the product-page JSON (sales count, histogram, variants, refund policy); review mode pages through written reviews.
4. **Storefront handling** — seller pages are parsed from their embedded JSON; every section is paginated and products de-duplicated by ID.
5. **Emit** — products (and optional creator records) land in the dataset as JSON, exportable as CSV/Excel/XML via the Apify API.

### Input Configuration

All fields are optional — provide at least one of `searchQueries`, `tags`, `categories`, `sellerUrls`, or `productUrls`.

| Field | Type | Default | Notes |
|---|---|---|---|
| `searchQueries` | string\[] | — | Keywords for the discover catalog |
| `tags` | string\[] | — | Tag browse |
| `categories` | string\[] | — | Category paths (`3d/vrchat`) |
| `sellerUrls` | string\[] | — | Storefront URLs — every product of those creators |
| `productUrls` | string\[] | — | Direct product URLs (always detail-fetched) |
| `sort` | enum | `featured` | `featured`, `most_reviewed`, `highest_rated`, `newest`, `hot_and_new`, `staff_picks`, `price_asc`, `price_desc` |
| `minPrice` / `maxPrice` | integer | — | Price window in USD |
| `minRating` | integer | — | 0–5; unrated products are excluded when set |
| `nativeTypes` | enum\[] | all | `digital`, `course`, `ebook`, `membership`, `bundle`, `podcast`, `audiobook`, `newsletter`, `physical`, `commission`, `call`, `coffee`, `ticket` |
| `fileTypes` | string\[] | — | `pdf`, `mp4`, `zip`, `epub`, `psd`, `blend`, … (server-side) |
| `freeOnly` | boolean | `false` | Free or pay-what-you-want only |
| `payWhatYouWantOnly` | boolean | `false` | Buyer-sets-price only |
| `sellerVerifiedOnly` | boolean | `false` | Verified sellers only |
| `scrapeDetails` | boolean | `false` | Adds sales count, full description, histogram, variants… (one extra request per product) |
| `scrapeReviews` | boolean | `false` | Attaches written reviews (one request per ~20 reviews) |
| `maxReviewsPerProduct` | integer | `20` | Review cap per product |
| `includeSellerRecord` | boolean | `false` | Emit one `creator` record per unique seller |
| `enrichEmails` | boolean | `false` | Crawl creators' external sites for contact emails; implies `includeSellerRecord` |
| `monitorMode` | boolean | `false` | Only emit new/changed products vs the previous run |
| `monitorKey` | string | `default` | Monitor memory namespace — one key per saved search |
| `maxItems` | integer | `1000` | Cap on product rows (creator records excluded) |
| `maxConcurrency` | integer | `6` | Parallelism for detail/review/creator fetches |
| `proxy` | object | — | Optional; set only if you hit rate limits |

#### Example — filtered market research

```json
{
  "searchQueries": ["notion template"],
  "minPrice": 20,
  "maxPrice": 50,
  "minRating": 4,
  "sort": "most_reviewed",
  "scrapeDetails": true,
  "maxItems": 200
}
```

#### Example — whole storefront + creator lead

```json
{
  "sellerUrls": ["https://liindy.gumroad.com"],
  "scrapeDetails": true,
  "includeSellerRecord": true
}
```

#### Example — niche watchlist (schedule this)

```json
{
  "categories": ["3d/vrchat"],
  "sort": "newest",
  "monitorMode": true,
  "monitorKey": "vrchat-newest",
  "maxItems": 300
}
```

### Output Overview

Product rows are flat JSON: identity (`id`, `permalink`, `url`), pricing (`priceCents`, `priceUsd`, `currency`, pay-what-you-want and recurrence flags), ratings (`ratingCount`, `ratingAverage`, and in detail mode the 1–5★ `ratingPercentages` histogram), the seller (name, ID, profile URL, verified flag), and content fields (`description`, `thumbnailUrl`, and in detail mode `descriptionHtml`, `covers`, `attributes`, `refundPolicy`).

Creator rows carry the seller's profile: bio, bio links, external website, Twitter/X handle, subdomain, verified state, product counts — plus contact fields when `enrichEmails` is on.

With `monitorMode`, every emitted row also carries `monitorStatus` (`new` or `changed`) and a `changes` array with field-level previous → current diffs.

### Output Samples

#### `type: "product"` — from a filtered keyword search with `scrapeDetails: true`

```jsonc
{
  "type": "product",
  "id": "dvIiGQILR7jh2t4YAVxgPw==",
  "permalink": "dvspii",
  "name": "Your ADHD Mynd - Notion Template (2026)",
  "url": "https://notionforadhd.gumroad.com/l/youradhdmynd",
  "nativeType": "digital",
  "priceCents": 4500,
  "priceUsd": 45,
  "currency": "usd",
  "isPayWhatYouWant": false,
  "ratingCount": 6,
  "ratingAverage": 4.8,
  "sellerName": "Braelyn | Mynd for ADHD",
  "sellerId": "645378619833",
  "sellerProfileUrl": "https://notionforadhd.gumroad.com/",
  "sellerVerified": false,
  "thumbnailUrl": "https://public-files.gumroad.com/6g2w9ygqknype6h6m60b402dokyh",
  "description": "🧠 Your ADHD Mynd — A beautifully built Notion system designed to meet your brain where it's at…",
  // — detail-mode fields —
  "salesCount": 595,
  "summary": "A beautiful multi-page Notion dashboard to manage all areas of your life.",
  "priceFormatted": "$45",
  "ratingPercentages": [0, 0, 0, 17, 83],
  "isRecurringBilling": false,
  "isTieredMembership": false,
  "options": [],
  "covers": [{ "url": "https://public-files.gumroad.com/5an7d0i3…", "type": "image", "filetype": "png" }],
  "refundPolicy": { "title": "30-day money back guarantee" },
  "scrapedAt": "2026-07-18T11:11:04.986Z"
}
```

#### `type: "creator"` — with `enrichEmails: true`

```jsonc
{
  "type": "creator",
  "id": "5544649096421",
  "name": "Sébastien Dubois",
  "bio": "Organize your thoughts, life & work⚡\nNew store: https://store.dsebastien.net",
  "bioLinks": ["https://store.dsebastien.net"],
  "externalWebsite": "https://store.dsebastien.net",
  "twitterHandle": "dSebastien",
  "subdomain": "developassion.gumroad.com",
  "isVerified": false,
  "profileUrl": "https://developassion.gumroad.com/",
  "sectionsCount": 7,
  "listedProducts": 12,
  "productsSeenThisRun": 4,
  // — enrichment fields (best-effort) —
  "contactEmail": null,
  "contactEmails": [],
  "contactWebsite": "https://store.dsebastien.net",
  "takesPayments": true,
  "paymentProcessors": ["gumroad"],
  "paymentConfidence": "high",
  "scrapedAt": "2026-07-18T11:41:50.256Z"
}
```

#### Review objects — attached under `reviews` with `scrapeReviews: true`

```jsonc
"reviews": [
  {
    "id": "Jn0WLqSKcvewmBXo4BipTw==",
    "rating": 5,
    "message": "Excited to put this to use!",
    "raterName": "Honour Indigo",
    "response": null,   // seller's public reply, when present
    "video": null
  }
]
```

### Key Output Fields

**Identity & pricing** — `id`, `permalink`, `name`, `url`, `nativeType`, `priceCents`, `priceUsd`, `currency`, `isPayWhatYouWant`, `recurrence`, `durationInMonths`, `priceFormatted`, `suggestedPriceCents`.

**Ratings & traction** — `ratingCount`, `ratingAverage`, `ratingPercentages` (1–5★ histogram), `salesCount` (only when the seller displays it publicly), `quantityRemaining`, `isSalesLimited`.

**Seller** — `sellerName`, `sellerId`, `sellerProfileUrl`, `sellerVerified`; creator records add `bio`, `bioLinks`, `externalWebsite`, `twitterHandle`, `subdomain`, `sectionsCount`, `listedProducts`.

**Content** — `description`, `descriptionHtml`, `summary`, `thumbnailUrl`, `covers`, `attributes`, `refundPolicy`, `options` (variants/tiers), `recurrences` (membership billing), `freeTrial`.

**Lead-gen (opt-in)** — `contactEmail`, `contactEmails`, `contactWebsite`, `emailEnrichment`, `takesPayments`, `paymentProcessors`, `paymentConfidence`.

**Monitoring (opt-in)** — `monitorStatus`, `changes` (field-level diffs), plus `createdAt` / `updatedAt` timestamps from detail mode.

### FAQ

**Which URLs work as `sellerUrls`?**
Any Gumroad storefront: `https://<name>.gumroad.com` subdomains and custom-domain stores powered by Gumroad. The actor reads the store's embedded JSON, so themed stores work too.

**Why is `salesCount` sometimes null?**
Gumroad only exposes the sales count when the seller has chosen to display it. That's a property of the listing, not a scraping gap.

**Do price filters work with non-USD prices?**
Filters are evaluated in USD. Gumroad converts listings server-side; the actor re-checks the returned USD price so the window you set is the window you get.

**How many reviews can I get per product?**
As many as exist, paged ~20 per request — set `maxReviewsPerProduct`. Only written reviews are available (Gumroad doesn't publish reviewer-only star votes individually).

**Will I always get an email for every creator?**
No — email discovery is best-effort by design. It works when a creator links an external website (bio link or custom domain); creators with no web presence outside Gumroad yield `contactEmail: null`. The `contact-email` event is only charged when an email is actually found.

**What exactly does monitor mode remember?**
A named key-value store (per `monitorKey`) keeps a snapshot of price, rating count/average, sales count, quantity and name per product. The next run emits only rows whose snapshot changed (with a field-level `changes` diff) or that are brand new.

**Does it need a proxy?**
Usually no — Gumroad's public endpoints are lenient. The `proxy` input exists for high-volume runs that hit per-IP rate limits.

**Can it scrape the files/downloads of a product?**
No. Only public listing data — never purchased content, downloads, or anything behind login.

### Support

- **Issues tab** — fastest way to report a broken field or request a feature; every issue gets a reply.
- **Email** — <mrmemo230@gmail.com>

### Additional Services

Need a custom export shape, a merged pipeline (e.g. Gumroad + Etsy for a full digital-product market view), scheduled delivery to your warehouse, or a niche-specific variant? Open an issue or email — custom builds and tailored data feeds are available.

### Explore More Scrapers

- [Etsy Scraper — Products, Reviews & Seller Leads](https://apify.com/memo23/etsy-scraper)
- [Flippa Scraper — Listings with Financials & Emails](https://apify.com/memo23/flippa-scraper)
- [Empire Flippers — Businesses For Sale + Financials](https://apify.com/memo23/empireflippers-scraper)
- [Amazon Seller Contact Scraper — Emails, Phone, VAT](https://apify.com/memo23/amazon-sellers-scraper)
- [eBay — Active & Sold Listings, Prices & Analytics](https://apify.com/memo23/ebay-search-scraper-ppe)

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Gumroad, Inc. or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available product, storefront, and review pages — no authenticated endpoints, paid features, purchased content, or anything behind the gumroad.com login wall. Users are responsible for ensuring their use complies with Gumroad's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

gumroad scraper, gumroad product scraper, gumroad data extraction, gumroad api alternative, gumroad seller scraper, gumroad storefront scraper, gumroad reviews scraper, gumroad creator emails, gumroad price tracker, gumroad market research, digital product research, digital product price monitoring, creator economy data, creator lead generation, notion template market data, vrchat asset market data, best selling gumroad products, gumroad sales count, gumroad json export, gumroad csv export, indie product analytics, web scraping gumroad, apify gumroad actor

# Actor input Schema

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

Keywords to search Gumroad's discover catalog (e.g. <code>notion template</code>, <code>lightroom presets</code>, <code>ai course</code>).

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

Browse by Gumroad tag instead of / in addition to free-text search (e.g. <code>notion</code>, <code>design</code>, <code>photography</code>).

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

Browse by category path as it appears in Gumroad discover URLs — e.g. <code>design</code>, <code>3d/vrchat</code>, <code>software-development</code>, <code>business-and-money</code>, <code>drawing-and-painting</code>.

## `sellerUrls` (type: `array`):

Creator storefront URLs — every product of that creator is scraped (all profile sections, de-duplicated). Works with subdomains (<code>https://seller.gumroad.com</code>) and custom-domain Gumroad stores.

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

Direct Gumroad product URLs (e.g. <code>https://seller.gumroad.com/l/permalink</code> or <code>https://gumroad.com/l/permalink</code>). Fetched directly with full detail, bypassing search and filters.

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

How search / tag / category results are ordered.

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

Only include products priced at or above this amount (USD).

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

Only include products priced at or below this amount (USD).

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

Only include products with an average rating at or above this value. Products with no ratings are excluded when set.

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

Only include these product types. Leave empty for all.

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

Only include products that ship these file types (e.g. <code>pdf</code>, <code>mp4</code>, <code>zip</code>, <code>mp3</code>, <code>epub</code>, <code>psd</code>, <code>blend</code>). Applied server-side by Gumroad.

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

Only include free or pay-what-you-want products.

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

Only include products where the buyer sets the price.

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

Only include products from verified Gumroad sellers.

## `scrapeDetails` (type: `boolean`):

When ON, each product's page is fetched to add sales count, full HTML description, rating histogram, variants/tiers, membership billing cycles, covers, attributes and refund policy. Slower and costs more (one extra request per product). When OFF (default), the rich search-card data is returned — much cheaper.

## `scrapeReviews` (type: `boolean`):

When ON, written reviews (text, star rating, reviewer name, seller reply) are attached to each product row under <code>reviews</code>. One extra request per ~20 reviews.

## `maxReviewsPerProduct` (type: `integer`):

Cap on written reviews fetched per product (only used when 'Scrape written reviews' is on).

## `includeSellerRecord` (type: `boolean`):

When ON, one <code>type: "creator"</code> record is emitted per unique seller encountered — name, bio, bio links, external website, Twitter/X handle, subdomain, verified state, product counts. One extra request per unique creator.

## `enrichEmails` (type: `boolean`):

For creators that link an external website (bio link or custom store domain), crawl it for contact emails and payment-stack signals. Adds <code>contactEmail</code>, <code>contactEmails</code> and <code>emailEnrichment</code> to creator records. Implies 'Emit creator records'. Best-effort — creators without an external site yield no email.

## `monitorMode` (type: `boolean`):

Remember products between runs (in a named key-value store) and only emit records that are NEW or CHANGED since the last run — price moves, new ratings, sales-count changes. Pairs well with a schedule.

## `monitorKey` (type: `string`):

Name for this monitor's memory. Use a distinct key per saved search/niche so they don't share state (e.g. <code>notion-templates</code>, <code>vrchat-avatars</code>).

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

Maximum number of products to return across all inputs (creator records don't count toward this).

## `maxConcurrency` (type: `integer`):

How many detail / review / creator pages to fetch in parallel.

## `proxy` (type: `object`):

Optional. Set only if you hit rate limits.

## Actor input object example

```json
{
  "searchQueries": [
    "notion template"
  ],
  "sort": "featured",
  "freeOnly": false,
  "payWhatYouWantOnly": false,
  "sellerVerifiedOnly": false,
  "scrapeDetails": false,
  "scrapeReviews": false,
  "maxReviewsPerProduct": 20,
  "includeSellerRecord": false,
  "enrichEmails": false,
  "monitorMode": false,
  "monitorKey": "default",
  "maxItems": 100,
  "maxConcurrency": 6
}
```

# 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": [
        "notion template"
    ],
    "maxItems": 100,
    "maxConcurrency": 6
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "searchQueries": ["notion template"],
    "maxItems": 100,
    "maxConcurrency": 6,
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/gumroad-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 '{
  "searchQueries": [
    "notion template"
  ],
  "maxItems": 100,
  "maxConcurrency": 6
}' |
apify call memo23/gumroad-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zc9iFinBeqCfUYSal/builds/1arqSUGOEZTqPighH/openapi.json
