# Redbubble Scraper (`solidcode/redbubble-com-scraper`) Actor

\[💰 $5 / 1K] Scrape Redbubble listings: title, artist, product type, price, discount, tags, image. Search by keyword with product-type and sort filters, or paste any search, shop, category, or artist URL. For print-on-demand sellers tracking niches, pricing, and trends.

- **URL**: https://apify.com/solidcode/redbubble-com-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 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.
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

## Redbubble Scraper

Pull product listings from Redbubble at scale — design title, artist name and shop URL, product type, live price, currency, active discount, design tags, preview image, and stable design/product IDs for every listing in a search, category, shop, or artist's store. Built for print-on-demand sellers, niche researchers, and dropshippers who need to track trending designs and pricing across Redbubble without hand-building search URLs one page at a time.

### Why This Scraper?

- **Unlimited products from any artist's shop** — paste a `/people/<artist>/shop` URL and pull the artist's entire catalog uncapped, while keyword and category searches max out at roughly 820 products each.
- **21 product-type filters in one dropdown** — scope a keyword search to stickers, laptop stickers, magnets, t-shirts, hoodies, phone cases (iPhone and Samsung), mugs, pillows, posters, art/canvas/photo prints, greeting cards, mouse pads, hats, caps, or pins, without touching a URL.
- **Four sort modes** — collect results by Most Relevant, Most Recent, Top Selling, or Trending to surface either bestsellers or the newest uploads.
- **Design tags array on every row** — the exact keyword tags the artist attached to each design, ready for niche discovery and keyword-gap research.
- **Live price, currency, and discount percent** — the current listing price, its ISO currency code, and the active discount percentage on every product for pricing intelligence.
- **Direct artist shop URL on every product** — each row carries the seller's username and a clickable link to their Redbubble store, turning any search into an artist lead list.
- **Stable numeric work and product IDs** — a `workId` shared across every product type of one design plus a per-listing `productId`, so you can dedupe and join runs reliably even when titles repeat.
- **Type a keyword, skip the URL** — enter "cat stickers" and each phrase runs its own search; mix keywords and pasted URLs in a single run.

### Use Cases

**Market & Niche Research**
- Map which designs dominate a niche by Top Selling sort
- Mine the design tags array to find underserved keyword niches
- Compare design saturation across product types (stickers vs. tees)
- Track how many fresh designs enter a niche via Most Recent sort

**Trend Spotting**
- Pull the Trending sort to catch designs gaining momentum early
- Monitor a category weekly to detect rising themes before they peak
- Spot seasonal design waves by re-running the same keyword over time

**Pricing Intelligence**
- Benchmark listing prices and active discounts across a niche
- Track discount percentages to time promotions against competitors
- Compare price points by product type for the same design theme

**Lead Generation & Artist Outreach**
- Build artist contact lists from username and shop URL on every row
- Identify prolific sellers in a niche by pulling their full shop catalog
- Source independent artists for licensing or collaboration outreach

**Catalog & Data Integration**
- Feed live product data into dashboards and price monitors
- Enrich design databases with stable work and product IDs
- Power alerting systems that flag new listings or price changes

### Getting Started

#### Simple Keyword Search

The simplest way to start — one keyword, 50 products:

```json
{
    "searchQueries": ["cat stickers"],
    "maxResults": 50
}
````

#### Paste a Redbubble URL

Paste any search, category, shop, or artist URL — filters in the URL are honored exactly as pasted:

```json
{
    "searchUrls": [
        "https://www.redbubble.com/shop?query=retro+poster",
        "https://www.redbubble.com/people/someartist/shop"
    ],
    "maxResults": 200
}
```

#### Filtered Keyword Search

Scope keywords to one product type and sort by bestsellers:

```json
{
    "searchQueries": ["vintage flowers", "mushroom"],
    "productType": "sticker",
    "sortBy": "top-selling",
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["cat stickers"]` | Keywords to search on Redbubble. Each keyword runs its own search — no URL building needed. Leave empty if you only use Redbubble URLs. |
| `searchUrls` | string\[] | `[]` | Redbubble search, category, shop, or artist-shop URLs. Any filters in the URL — keyword, product type, sort — are honored exactly as pasted. |

#### Filters

These apply to Search Keywords only. Pasted URLs keep the product type and sort encoded in the URL itself.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `productType` | select | (all types) | Limit keyword results to one of 21 product types: Sticker, Laptop Sticker, Magnet, T-Shirt, Clothing, Hoodie / Sweatshirt, Phone Case, iPhone Case, Samsung Case, Mug, Pillow, Print, Poster, Art Print, Canvas Print, Photo Print, Greeting Card, Mouse Pad, Hat, Cap, or Pin / Button. Leave empty to include all. |
| `sortBy` | select | `Most Relevant` | Order in which keyword results are collected: Most Relevant, Most Recent, Top Selling, or Trending. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum products per keyword or URL. Set to 0 for unlimited. Keyword searches and search/shop/category URLs cap at roughly 820 products each; artist-shop URLs have no cap. Start with 20-50 to test, then increase. |

### Output

Each row is one product listing — a design printed on a specific product type:

```json
{
    "title": "Curious Cat Sticker Pack",
    "artistName": "PixelWhisker",
    "artistUrl": "https://www.redbubble.com/people/PixelWhisker/shop",
    "productType": "Sticker",
    "price": 2.47,
    "currency": "USD",
    "discountPercent": 20,
    "tags": ["cat", "kitten", "cute", "pet", "feline", "kawaii"],
    "imageUrl": "https://ih1.redbubble.net/image.123456789.0001/st,small,507x507-pad,600x600,f8f8f8.jpg",
    "url": "https://www.redbubble.com/i/sticker/Curious-Cat-by-PixelWhisker/123456789.EJUG5",
    "workId": "123456789",
    "productId": "987654321"
}
```

#### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Design / product name |
| `artistName` | string | Independent artist's display name |
| `artistUrl` | string | Link to the artist's Redbubble shop |
| `productType` | string | Product the design is printed on (e.g. "Sticker", "Classic T-Shirt", "Poster") |
| `price` | number | Current listing price |
| `currency` | string | ISO currency code (e.g. "USD") |
| `discountPercent` | number | Active discount percentage (0 if none) |
| `tags` | string\[] | Design keyword tags set by the artist |
| `imageUrl` | string | Primary product preview image URL |
| `url` | string | Canonical product listing URL |
| `workId` | string | Design ID, shared across every product type of the same design |
| `productId` | string | Listing ID for this specific design + product-type combination |

### Tips for Best Results

- **Use artist-shop URLs for full catalogs** — a `/people/<artist>/shop` URL returns the seller's entire store uncapped, unlike the ~820-product ceiling on keyword and category searches. To pull more than 820 products on a theme, target the top artists' shops directly.
- **Start small** — set `maxResults` to 20-50 on your first run to confirm the data matches your needs, then scale up.
- **Mine the tags array for niche discovery** — the per-design `tags` are the artist's own keywords. Aggregate them across a run to find adjacent niches and keyword gaps competitors miss.
- **Sort by Top Selling for proven designs, Most Recent for whitespace** — bestsellers reveal what already converts; the newest uploads reveal where the niche is heading.
- **Combine keywords and URLs in one run** — mix several keywords with pasted category and artist URLs to cover a niche from every angle in a single invocation.
- **Join runs on `workId`** — because one design's `workId` is stable across product types and re-runs, use it to dedupe and track the same design over time.
- **Filters apply to keywords, not pasted URLs** — set Product Type and Sort for keyword searches; for a pasted URL, encode those choices in the URL itself before pasting.

### Pricing

**From $5.00 per 1,000 results** — well below the market rate for Redbubble extraction. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.53 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.30 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.00 | $50.00 |
| 100,000 | $600.00 | $565.00 | $530.00 | $500.00 |

A "result" is any product row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, trend analysis, pricing intelligence, and artist discovery. Users are responsible for complying with applicable laws and Redbubble's Terms of Service. Respect artists' intellectual property — design titles, images, and tags belong to their creators. Do not use extracted data for spam, harassment, design theft, or any illegal purpose.

# Actor input Schema

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

Type what you're looking for on Redbubble, e.g. 'cat stickers' or 'retro poster'. Each keyword runs its own search — no need to build a URL. Leave empty if you only use Search URLs below.

## `searchUrls` (type: `array`):

Paste Redbubble search, shop, category, or artist-shop URLs directly (for example https://www.redbubble.com/shop?query=cat+stickers or https://www.redbubble.com/people/someartist/shop). Any filters already in the URL — keyword, product type, sort — are honored exactly as pasted. The Product Type and Sort settings below do NOT apply to pasted URLs.

## `productType` (type: `string`):

Limit Search Keywords results to a single product type. Applies to Search Keywords only — ignored for pasted URLs (those keep the product type encoded in the URL). Leave empty to include all product types.

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

Order in which Search Keywords results are collected. Only applies to Search Keywords — ignored for pasted URLs (those keep the sort encoded in the URL).

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

Maximum number of products to return per search keyword or URL. Set to 0 for unlimited. Note: Redbubble caps keyword searches and search/shop/category URLs at roughly 820 products each, so values above ~820 won't return more for those (artist-shop URLs have no such cap). Tip: start with 20-50 to test, then increase.

## Actor input object example

```json
{
  "searchQueries": [
    "cat stickers"
  ],
  "searchUrls": [],
  "sortBy": "relevant",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped Redbubble products with key fields.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "cat stickers"
    ],
    "searchUrls": [],
    "sortBy": "relevant",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/redbubble-com-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": ["cat stickers"],
    "searchUrls": [],
    "sortBy": "relevant",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/redbubble-com-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": [
    "cat stickers"
  ],
  "searchUrls": [],
  "sortBy": "relevant",
  "maxResults": 100
}' |
apify call solidcode/redbubble-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redbubble Scraper",
        "description": "[💰 $5 / 1K] Scrape Redbubble listings: title, artist, product type, price, discount, tags, image. Search by keyword with product-type and sort filters, or paste any search, shop, category, or artist URL. For print-on-demand sellers tracking niches, pricing, and trends.",
        "version": "1.0",
        "x-build-id": "rZBzfOW6TmWlaMaJ3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~redbubble-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-redbubble-com-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/solidcode~redbubble-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-redbubble-com-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/solidcode~redbubble-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-redbubble-com-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 Keywords",
                        "type": "array",
                        "description": "Type what you're looking for on Redbubble, e.g. 'cat stickers' or 'retro poster'. Each keyword runs its own search — no need to build a URL. Leave empty if you only use Search URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Redbubble URLs",
                        "type": "array",
                        "description": "Paste Redbubble search, shop, category, or artist-shop URLs directly (for example https://www.redbubble.com/shop?query=cat+stickers or https://www.redbubble.com/people/someartist/shop). Any filters already in the URL — keyword, product type, sort — are honored exactly as pasted. The Product Type and Sort settings below do NOT apply to pasted URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productType": {
                        "title": "Product Type",
                        "enum": [
                            "sticker",
                            "laptop-sticker",
                            "magnet",
                            "t-shirt",
                            "clothing",
                            "hoodie",
                            "phone-case",
                            "iphone-case",
                            "samsung-case",
                            "mug",
                            "pillow",
                            "print",
                            "poster",
                            "art-print",
                            "canvas-print",
                            "photo-print",
                            "greeting-card",
                            "mouse-pad",
                            "hat",
                            "cap",
                            "pin"
                        ],
                        "type": "string",
                        "description": "Limit Search Keywords results to a single product type. Applies to Search Keywords only — ignored for pasted URLs (those keep the product type encoded in the URL). Leave empty to include all product types."
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "relevant",
                            "recent",
                            "top-selling",
                            "trending"
                        ],
                        "type": "string",
                        "description": "Order in which Search Keywords results are collected. Only applies to Search Keywords — ignored for pasted URLs (those keep the sort encoded in the URL).",
                        "default": "relevant"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to return per search keyword or URL. Set to 0 for unlimited. Note: Redbubble caps keyword searches and search/shop/category URLs at roughly 820 products each, so values above ~820 won't return more for those (artist-shop URLs have no such cap). Tip: start with 20-50 to test, then increase.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
