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

Extract Gumroad digital products: name, price, ratings, seller info, product type, and more. Scrape by keyword search, seller profile, or direct product URL. No API key needed.

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

## Pricing

from $0.60 / 1,000 product scrapeds

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/platform/actors/running/actors-in-store#pay-per-event

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

### 🛒 What does Gumroad Product Scraper do?

**Gumroad Product Scraper** extracts digital product data from [Gumroad](https://gumroad.com) — the leading marketplace for indie creators selling ebooks, courses, templates, software, and more.

You can scrape by:

- 🔍 **Search keywords** — find all products matching "notion template", "python course", or any other term
- 🏷️ **Category/tag** — scrape all products in a category (e.g. design, education, development)
- 📦 **Product URL** — extract data from a specific product page
- 👤 **Seller profile** — collect every product from a specific creator

The scraper extracts product name, price, ratings, seller info, product type, thumbnail, tags, description, and more — no API key required.

---

### 👥 Who is Gumroad Product Scraper for?

**Market researchers** tracking pricing and demand across the creator economy.

**Indie hackers and entrepreneurs** studying what digital products are selling in their niche before launching their own.

**Affiliate marketers** building product comparison sites in Gumroad niches.

**Data analysts** studying the creator economy, ebook market, or digital goods pricing trends.

**Developers and agencies** building tools for clients who sell on Gumroad.

**Investors and VCs** validating market size for creator economy opportunities.

---

### 🌟 Why use Gumroad Product Scraper?

- ✅ **No API key or Gumroad account needed** — public data, no authentication
- ✅ **No proxy required** — Gumroad serves HTML without bot blocking
- ✅ **Paginated search** — automatically loops through all result pages
- ✅ **Multiple input modes** — search, product URL, seller profile, or discover URL
- ✅ **Optional detail enrichment** — fetch full description, attributes, and covers
- ✅ **Structured JSON output** — ready for spreadsheets, databases, or analytics tools
- ✅ **Cheap to run** — HTTP-only, 256 MB, fast

---

### 📊 What data does it extract?

| Field | Description |
|-------|-------------|
| `name` | Product title |
| `productUrl` | Full canonical product URL |
| `permalink` | Gumroad short ID |
| `priceUsd` | Price in USD (float) |
| `priceCents` | Raw price in cents |
| `currency` | Currency code (usd, eur, etc.) |
| `isPayWhatYouWant` | PWYW flag |
| `productType` | Type: ebook, course, template, bundle, software, etc. |
| `ratingAverage` | Average star rating (1–5) |
| `ratingCount` | Total number of ratings/reviews |
| `sellerName` | Creator display name |
| `sellerProfileUrl` | Creator's Gumroad profile URL |
| `sellerVerified` | Whether creator is Gumroad-verified |
| `thumbnailUrl` | Product cover/thumbnail image URL |
| `description` | Short product summary |
| `descriptionHtml` | Full HTML description (when detail fetch enabled) |
| `salesCount` | Number of sales (when available) |
| `isPhysical` | Physical product flag |
| `isSubscription` | Recurring billing/subscription flag |
| `tags` | Tags from search aggregation |
| `attributes` | Product attributes (pages, file size, etc.) |
| `scrapedAt` | ISO 8601 timestamp |

---

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

This actor uses **Pay-Per-Event (PPE)** pricing — you pay only for what you collect:

| Event | FREE tier | What it covers |
|-------|-----------|----------------|
| Actor start | $0.005 | One-time per run |
| Product scraped | $0.001 | Per product saved |

**Example costs:**
- 100 products: ~$0.105
- 500 products: ~$0.505
- 1,000 products: ~$1.005

Higher Apify subscription tiers (Bronze, Silver, Gold, Platinum, Diamond) get up to 60% discount on per-product pricing. No Apify subscription? You still get a generous free tier.

---

### 🚀 How to scrape Gumroad products — step by step

1. **Open** [Gumroad Product Scraper](https://apify.com/automation-lab/gumroad-product-scraper) on Apify
2. **Enter your search** — type keywords like `notion template` or `python course` in **Search queries**
3. **Set max results** — choose how many products to collect per query (default: 50)
4. **Optional: paste URLs** — add specific product, seller, or Gumroad Discover URLs
5. **Click Start** — the actor runs and populates your dataset
6. **Download results** — export as JSON, CSV, or Excel from the dataset tab

---

### ⚙️ Input configuration

#### Search queries
List of keywords to search on Gumroad Discover. One search per line. Example:
````

notion template
python course
figma ui kit

````

#### Start URLs
Gumroad URLs to scrape directly. Supports:
- **Product page**: `https://seller.gumroad.com/l/permalink`
- **Seller profile**: `https://seller.gumroad.com`
- **Discover/category**: `https://gumroad.com/discover?tags[]=design`

#### Max results per query/URL
Maximum number of products to collect per query or URL. Set to `0` for unlimited. Default: `50`.

#### Fetch product details
When enabled, visits each product page to retrieve: full HTML description, short summary, product attributes (pages, size, length), and additional cover images. Adds one extra HTTP request per product but significantly enriches the data.

#### Sort by
How to order search results:
- **Featured** (default) — Gumroad's editorial ranking
- **Newest** — most recently published
- **Top rated** — highest rated products first
- **Most reviewed** — most reviewed products first

---

### 📤 Output format

Each product is stored as a JSON object in the dataset:

```json
{
  "name": "The Freelancer's SEO Playbook",
  "permalink": "xgdmn",
  "productUrl": "https://johndoe.gumroad.com/l/xgdmn",
  "priceUsd": 29.00,
  "priceCents": 2900,
  "currency": "usd",
  "isPayWhatYouWant": false,
  "productType": "ebook",
  "ratingAverage": 4.9,
  "ratingCount": 143,
  "sellerName": "John Doe",
  "sellerProfileUrl": "https://johndoe.gumroad.com",
  "sellerVerified": false,
  "thumbnailUrl": "https://public-files.gumroad.com/...",
  "description": "A complete SEO guide for freelancers...",
  "descriptionHtml": null,
  "salesCount": null,
  "isPhysical": false,
  "isSubscription": false,
  "tags": ["seo", "freelance", "marketing"],
  "attributes": [],
  "scrapedAt": "2026-04-06T12:00:00.000Z"
}
````

***

### 💡 Tips for best results

- **Use specific keywords** — `notion productivity template` returns more relevant results than just `template`
- **Combine search + profile scraping** — search for a niche, then deep-dive on top sellers
- **Disable detail fetch for bulk** — scraping 1,000 products is 2x faster without detail pages
- **Use discover URLs for categories** — go to Gumroad, filter by category/tag, then copy the URL and paste it as a start URL
- **Set maxResults = 0 carefully** — popular queries can have 10,000+ products

***

### 🔗 Integrations

#### Export to Google Sheets for market research

Run a search → download CSV → import to Sheets → sort by `ratingAverage` and `ratingCount` to find proven products in your niche.

#### Build a product comparison dashboard

Use the Apify API to feed Gumroad data into a Notion database, Airtable, or custom app for your content site.

#### Automate competitor monitoring

Schedule weekly runs on specific seller profiles to track new product launches and price changes from competitors.

#### Zapier / Make automation

Trigger Zapier or Make scenarios when new products appear in your target niche — send Slack alerts, add to CRM, or update databases.

***

### 🤖 API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/gumroad-product-scraper').call({
    searchQueries: ['notion template', 'figma ui kit'],
    maxResults: 100,
    fetchProductDetails: false,
    sortBy: 'top_rated',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/gumroad-product-scraper").call(run_input={
    "searchQueries": ["notion template", "figma ui kit"],
    "maxResults": 100,
    "fetchProductDetails": False,
    "sortBy": "top_rated",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["priceUsd"])
```

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~gumroad-product-scraper/runs?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "searchQueries": ["notion template"],
    "maxResults": 50,
    "sortBy": "featured"
  }'
```

***

### 🤖 Use with AI agents via MCP

Gumroad Product Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- *"Use automation-lab/gumroad-product-scraper to search for 'notion template' and find the top 20 products sorted by rating"*
- *"Get all products from Gumroad seller profile https://johndoe.gumroad.com"*
- *"Find the cheapest ebooks on Gumroad tagged 'marketing' using gumroad-product-scraper"*

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

***

### ⚖️ Is scraping Gumroad legal?

This actor only collects **publicly available data** — the same information visible to any visitor without logging in. No authentication, private data, or paywalled content is accessed.

Web scraping of public data is protected under the Computer Fraud and Abuse Act (CFAA) and affirmed by multiple court rulings (hiQ v. LinkedIn, 2022). Always use scraped data responsibly and in accordance with applicable laws in your jurisdiction.

***

### ❓ FAQ

**Does the actor require a Gumroad account or API key?**
No — it accesses only public pages, just like a normal browser visit. No login required.

**Does it need a proxy?**
No. Gumroad returns standard HTTP 200 responses without bot-blocking. This makes runs fast and cheap.

**Can I scrape all products from a specific seller?**
Yes — paste the seller's Gumroad profile URL (e.g. `https://johndoe.gumroad.com`) as a start URL and set `maxResults` to 0 for unlimited.

**Why is `salesCount` null for some products?**
Gumroad does not expose exact sales counts publicly in most cases. The field is null when Gumroad hides this data.

**The actor returned fewer results than expected — why?**
Gumroad's search may return fewer results than the `total` count suggests if some products are unpublished, region-restricted, or removed mid-scrape. This is a Gumroad-side limitation.

**I'm getting empty results for a query — what should I try?**
Try a simpler query (fewer words), check the spelling, or try the URL of a Gumroad Discover search with your filters applied.

***

### 🔗 Related scrapers

- [Etsy Scraper](https://apify.com/automation-lab/etsy-scraper) — scrape Etsy digital product listings
- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) — extract Amazon product data at scale
- [WooCommerce Scraper](https://apify.com/automation-lab/woocommerce-scraper) — scrape WooCommerce stores

# Actor input Schema

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

List of keywords to search on Gumroad Discover. Examples: <code>python course</code>, <code>notion template</code>, <code>ebook marketing</code>.

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

Gumroad URLs to scrape directly. Supported formats:<ul><li>Seller profile: <code>https://seller.gumroad.com</code></li><li>Product page: <code>https://seller.gumroad.com/l/permalink</code></li><li>Discover/category: <code>https://gumroad.com/discover?tags\[]=design</code></li></ul>

## `maxResults` (type: `integer`):

Maximum number of products to collect per search query or URL. Use <code>0</code> for unlimited (may be slow for popular queries).

## `fetchProductDetails` (type: `boolean`):

Visit each product page to fetch additional data: full HTML description, summary, attributes (pages, size), covers list, and accurate sales count. Adds ~1 request per product. Disable for faster bulk collection.

## `sortBy` (type: `string`):

Sort order for search query results.

## Actor input object example

```json
{
  "searchQueries": [
    "notion template"
  ],
  "startUrls": [],
  "maxResults": 50,
  "fetchProductDetails": false,
  "sortBy": "featured"
}
```

# Actor output Schema

## `products` (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 = {
    "searchQueries": [
        "notion template"
    ],
    "startUrls": [],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gumroad-product-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["notion template"],
    "startUrls": [],
    "maxResults": 50,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gumroad Product Scraper",
        "description": "Extract Gumroad digital products: name, price, ratings, seller info, product type, and more. Scrape by keyword search, seller profile, or direct product URL. No API key needed.",
        "version": "0.1",
        "x-build-id": "7X7EjhZctNMyamTF1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~gumroad-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-gumroad-product-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/automation-lab~gumroad-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-gumroad-product-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/automation-lab~gumroad-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-gumroad-product-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",
                "properties": {
                    "searchQueries": {
                        "title": "🔍 Search queries",
                        "type": "array",
                        "description": "List of keywords to search on Gumroad Discover. Examples: <code>python course</code>, <code>notion template</code>, <code>ebook marketing</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "🌐 Start URLs",
                        "type": "array",
                        "description": "Gumroad URLs to scrape directly. Supported formats:<ul><li>Seller profile: <code>https://seller.gumroad.com</code></li><li>Product page: <code>https://seller.gumroad.com/l/permalink</code></li><li>Discover/category: <code>https://gumroad.com/discover?tags[]=design</code></li></ul>",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "📦 Max results per query/URL",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to collect per search query or URL. Use <code>0</code> for unlimited (may be slow for popular queries)."
                    },
                    "fetchProductDetails": {
                        "title": "🔎 Fetch product details",
                        "type": "boolean",
                        "description": "Visit each product page to fetch additional data: full HTML description, summary, attributes (pages, size), covers list, and accurate sales count. Adds ~1 request per product. Disable for faster bulk collection.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "📊 Sort search results by",
                        "enum": [
                            "featured",
                            "newest",
                            "top_rated",
                            "most_reviewed"
                        ],
                        "type": "string",
                        "description": "Sort order for search query results.",
                        "default": "featured"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
