# Etsy Scraper 🛍️ Products, Reviews & Seller Leads (`memo23/etsy-scraper`) Actor

Turn Etsy into a seller lead list. Scrape products by URL or keyword, then enrich each with the shop's lifetime sales, Star-Seller status, listing count and contact email — data other scrapers skip. Prices (incl. ranges), ratings, reviews and variations included. JSON, CSV or Excel out.

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

## Pricing

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

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

## Etsy Scraper — Products, Shops, Reviews & Seller Leads

**Turn any Etsy URL into structured product *and* seller data.** Scrape products from any Etsy listing, search, category, or shop page — title, price (and full price range), images, rating, review count, variations, shipping, materials, and the description — then optionally enrich each one with **deep seller intelligence** (lifetime sales, Star-Seller status, listing count) and a **contact email**. JSON, CSV, or Excel out, billed per product.

![How Etsy Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-etsy.png)

> **Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Etsy, Inc. All trademarks are the property of their respective owners.

### Why use this scraper

Most Etsy scrapers stop at the product. This one keeps going to the **seller** — because that's where the money is for lead generation, supplier sourcing, and competitor analysis.

- 🎯 **Four starting points, one actor.** Paste a **product** URL (`/listing/{id}`), a **search** URL (`/search?q=…`), a **category** (`/c/…`), or a **shop** (`/shop/{name}`) — all are auto-classified and results pages are paginated for you.
- 💰 **Real prices, including ranges.** Fixed-price *and* variable products (e.g. "$8.86 – $50.59 across 96 variations") are parsed correctly from structured data — no `null` prices on multi-variation listings.
- 🏪 **Seller lead-gen (the differentiator).** Turn products into leads: lifetime **sales count**, **Star-Seller** badge, total listings, shop rating, and an optional **contact email** for the shop. Nobody else exposes this.
- ⚡ **No anti-bot headaches.** Etsy's bot wall is handled by a managed unblocker — you just get clean data back. No proxies, cookies, or captchas to configure.
- 📦 **30+ fields per product**, straight from Etsy's own embedded data (no fragile DOM scraping).

### Use cases

| Audience | What they get |
|---|---|
| **Print-on-demand / suppliers** | Find active, high-volume Etsy sellers (by sales count) + their contact email for B2B outreach |
| **Product & pricing researchers** | Price bands, variation pricing, ratings, and review volume across a niche or category |
| **Competitor / market analysts** | Track a shop's catalogue, sales trajectory, Star-Seller status, and bestsellers |
| **Dropshippers & resellers** | Source trending products with demand signals (favorites, review counts, sales) |
| **Agencies & lead-gen** | Build targeted lists of Etsy shops by category, with sales volume + contact data |

### How it works

1. **Classify** each start URL as a product or a results page (search / category / shop).
2. **Collect product links** from each results page and walk `?page=N` up to `maxItems`.
3. **Parse each product** from its embedded JSON-LD — price, rating, reviews, images, variations, shipping, shop.
4. **Optionally enrich** with the shop's seller stats (one cached fetch per shop) and a contact email.

### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `[]` | Etsy product / search / category / shop URLs. Mix freely. |
| `searchQuery` | string | – | A keyword (e.g. `ceramic mug`) turned into an Etsy search and paginated. |
| `maxItems` | integer | `1000` | Hard cap on products collected (controls billing). |
| `maxConcurrency` | integer | `5` | Product pages fetched in parallel. |
| `includeReviews` | boolean | `true` | Include the recent reviews carried in each listing's structured data. |
| `enrichSeller` | boolean | `false` | Add shop **sales count, Star-Seller, listing count, rating, description** (one fetch per shop). |
| `enrichEmails` | boolean | `false` | Best-effort contact-email discovery per shop (billed per email found). |

> **Tip:** apply your filters on etsy.com in the browser (category, price, sort…), copy the URL, and paste it into `startUrls`. The actor preserves the filter and paginates through the matches.

### Output sample

```json
{
  "type": "product",
  "productId": "4394846521",
  "url": "https://www.etsy.com/listing/4394846521/tomato-ceramic-mug-tumbler-handmade",
  "title": "Tomato Ceramic Mug Tumbler Handmade",
  "price": 36.0,
  "priceMax": 44.0,
  "offerCount": 53,
  "currency": "USD",
  "availability": "InStock",
  "rating": 4.9,
  "numberOfReviews": 32,
  "images": ["https://i.etsystatic.com/.../il_fullxfull.jpg", "…"],
  "categoryPath": ["Home & Living", "Kitchen & Dining", "Drink & Barware"],
  "material": "Ceramic",
  "shopName": "vampottery",
  "shopId": "12345678",
  "shopUrl": "https://www.etsy.com/shop/vampottery",
  "shippingOriginCountry": "US",
  "favorites": 1240,
  "variations": [{ "name": "Size", "options": ["10 oz", "12 oz", "14 oz", "16 oz"] }],
  "sampleReviews": [{ "author": "Jane D.", "rating": 5, "body": "Beautiful!", "date": "2026-05-02" }],
  "shopSales": 2087,
  "shopIsStarSeller": true,
  "shopNumberOfListings": 48,
  "scrapedAt": "2026-06-21T00:00:00.000Z"
}
````

### Key output fields

| Group | Fields |
|---|---|
| **Identifiers** | `type`, `productId`, `url`, `sku`, `scrapedAt` |
| **Product** | `title`, `description`, `category`, `categoryPath`, `material`, `gtin` |
| **Pricing** | `price` (from), `priceMax` (range top), `offerCount`, `currency`, `availability`, `quantityAvailable` |
| **Media** | `images[]`, `primaryImage` |
| **Shop** | `shopName`, `shopId`, `shopUrl`, `shopLogoUrl` |
| **Seller enrichment** *(opt-in)* | `shopSales`, `shopIsStarSeller`, `shopNumberOfListings`, `shopRating`, `shopReviewCount`, `shopSlogan`, `shopDescription` |
| **Email enrichment** *(opt-in)* | `contactEmail`, `contactWebsite`, `emailEnrichment` |
| **Shipping** | `shippingPrice`, `shippingCurrency`, `shippingOriginCountry` |
| **Engagement** | `favorites`, `rating`, `numberOfReviews`, `sampleReviews[]` |
| **Variations** | `variations[]` (option groups + values) |

### FAQ

**Which Etsy URLs are supported?**
Product (`/listing/{id}`), search (`/search?q=…`), category (`/c/…`), and shop (`/shop/{name}`) pages. Results pages are paginated automatically.

**Do I get prices for variable products?**
Yes — listings with per-variation pricing return `price` (the "from" price), `priceMax` (top of the range), and `offerCount`. Fixed-price listings just return `price`.

**Can I get the seller's sales and contact info?**
Enable `enrichSeller` for lifetime sales count, Star-Seller status, listing count and shop rating. Enable `enrichEmails` for a best-effort contact email (discovered from the shop's own website — many Etsy-only sellers won't have one, and you're never charged for a miss).

**Does it need a proxy?**
No. Etsy's bot protection is handled by a built-in managed unblocker — runs work out of the box.

**How many products can I get?**
As many as you want — set `maxItems`. Search and category pages paginate; a shop returns its whole catalogue.

### Support

- For issues or feature requests, use the **Issues** tab of this actor on the Apify Console.
- Customization or questions:
  - Website: <https://muhamed-didovic.github.io/>
  - Email: <muhamed.didovic@gmail.com>

### Additional Services

- Request customization or a whole-dataset export: <muhamed.didovic@gmail.com>
- API access (no Apify fee, usage fee only): <muhamed.didovic@gmail.com>

### Explore More Scrapers

Building an e-commerce or lead-gen dataset? Same author, same export format:

- **Amazon, Walmart, eBay** product & review scrapers
- **Yelp, Trustpilot, G2** business & review scrapers
- Plus jobs, real-estate, and social scrapers at [memo23's Apify profile](https://apify.com/memo23).

### ⚠️ Disclaimer

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

The scraper accesses only publicly available product and shop information on etsy.com — no buyer data, private messages, or content behind a login. Users are responsible for ensuring their use complies with etsy.com's Terms of Service, applicable data-protection law (GDPR, etc.), and any contractual obligations of their own organisation.

### SEO Keywords

etsy scraper, scrape etsy, etsy api, etsy product scraper, etsy data extraction, etsy listings scraper, etsy shop scraper, etsy seller scraper, etsy reviews scraper, etsy price monitoring, etsy product research, etsy lead generation, etsy seller leads, scrape etsy products, etsy competitor analysis, handmade marketplace scraper, etsy sales data, etsy shop data, etsy seller emails, etsy market research

# Actor input Schema

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

Etsy URLs to scrape — mix any of these four formats freely (one of each is prefilled as an example):<br><br>• <b>Any product</b> — <code>https://www.etsy.com/listing/{id}/...</code><br>• <b>Any category</b> — <code>https://www.etsy.com/c/...</code> (apply filters on Etsy, then copy the URL)<br>• <b>Keyword search</b> — <code>https://www.etsy.com/search?q=...</code><br>• <b>Any Etsy shop</b> — <code>https://www.etsy.com/shop/{name}</code>

## `searchQuery` (type: `string`):

A keyword to search Etsy for, e.g. "ceramic mug". Turned into an etsy.com/search URL and paginated. Use instead of, or alongside, startUrls.

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

Hard cap on the number of products collected across all start URLs. Use this to control billing.

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

Product pages fetched in parallel through the managed unblocker. Keep moderate (3–8); each page is one unblocker request.

## `includeReviews` (type: `boolean`):

Include the recent customer reviews carried in each listing's structured data (author, rating, text, date).

## `enrichSeller` (type: `boolean`):

Fetch each unique shop's page to add lifetime sales count, Star-Seller status, total listings, shop rating, and shop description/slogan. One extra request per shop (cached, so a shop is fetched at most once per run).

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

Best-effort: discover each shop's own website (from its name + country) and harvest a contact email. Adds contactEmail, contactWebsite and a detailed emailEnrichment object. Billed per email found — never charged for misses.

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

Proxy used for the direct enrichment fetches (e.g. seller email discovery). Etsy product/shop pages are fetched through a built-in managed unblocker, so this setting does not affect them. Paying users are routed through a premium residential pool automatically.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.etsy.com/listing/743657804/sheepskin-slippers-wool-slippers-fur",
    "https://www.etsy.com/c/clothing-and-shoes?ref=catnav-10923",
    "https://www.etsy.com/search?q=apple%20watch",
    "https://www.etsy.com/shop/PetiteFraise"
  ],
  "maxItems": 1000,
  "maxConcurrency": 5,
  "includeReviews": true,
  "enrichSeller": false,
  "enrichEmails": false,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.etsy.com/listing/743657804/sheepskin-slippers-wool-slippers-fur",
        "https://www.etsy.com/c/clothing-and-shoes?ref=catnav-10923",
        "https://www.etsy.com/search?q=apple%20watch",
        "https://www.etsy.com/shop/PetiteFraise"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/etsy-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 = {
    "startUrls": [
        "https://www.etsy.com/listing/743657804/sheepskin-slippers-wool-slippers-fur",
        "https://www.etsy.com/c/clothing-and-shoes?ref=catnav-10923",
        "https://www.etsy.com/search?q=apple%20watch",
        "https://www.etsy.com/shop/PetiteFraise",
    ],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/etsy-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 '{
  "startUrls": [
    "https://www.etsy.com/listing/743657804/sheepskin-slippers-wool-slippers-fur",
    "https://www.etsy.com/c/clothing-and-shoes?ref=catnav-10923",
    "https://www.etsy.com/search?q=apple%20watch",
    "https://www.etsy.com/shop/PetiteFraise"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call memo23/etsy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Scraper 🛍️ Products, Reviews & Seller Leads",
        "description": "Turn Etsy into a seller lead list. Scrape products by URL or keyword, then enrich each with the shop's lifetime sales, Star-Seller status, listing count and contact email — data other scrapers skip. Prices (incl. ranges), ratings, reviews and variations included. JSON, CSV or Excel out.",
        "version": "0.0",
        "x-build-id": "QvWlZ7nSqs3lQPkgn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~etsy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-etsy-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/memo23~etsy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-etsy-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/memo23~etsy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-etsy-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": {
                    "startUrls": {
                        "title": "Etsy URLs",
                        "type": "array",
                        "description": "Etsy URLs to scrape — mix any of these four formats freely (one of each is prefilled as an example):<br><br>• <b>Any product</b> — <code>https://www.etsy.com/listing/{id}/...</code><br>• <b>Any category</b> — <code>https://www.etsy.com/c/...</code> (apply filters on Etsy, then copy the URL)<br>• <b>Keyword search</b> — <code>https://www.etsy.com/search?q=...</code><br>• <b>Any Etsy shop</b> — <code>https://www.etsy.com/shop/{name}</code>",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search keyword (optional)",
                        "type": "string",
                        "description": "A keyword to search Etsy for, e.g. \"ceramic mug\". Turned into an etsy.com/search URL and paginated. Use instead of, or alongside, startUrls."
                    },
                    "maxItems": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of products collected across all start URLs. Use this to control billing.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Product pages fetched in parallel through the managed unblocker. Keep moderate (3–8); each page is one unblocker request.",
                        "default": 5
                    },
                    "includeReviews": {
                        "title": "Include sample reviews",
                        "type": "boolean",
                        "description": "Include the recent customer reviews carried in each listing's structured data (author, rating, text, date).",
                        "default": true
                    },
                    "enrichSeller": {
                        "title": "Enrich with shop/seller data (sales, star-seller, listings)",
                        "type": "boolean",
                        "description": "Fetch each unique shop's page to add lifetime sales count, Star-Seller status, total listings, shop rating, and shop description/slogan. One extra request per shop (cached, so a shop is fetched at most once per run).",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Enrich with seller contact emails (experimental, billed per email)",
                        "type": "boolean",
                        "description": "Best-effort: discover each shop's own website (from its name + country) and harvest a contact email. Adds contactEmail, contactWebsite and a detailed emailEnrichment object. Billed per email found — never charged for misses.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for the direct enrichment fetches (e.g. seller email discovery). Etsy product/shop pages are fetched through a built-in managed unblocker, so this setting does not affect them. Paying users are routed through a premium residential pool automatically.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
