# Etsy Review Photo Scraper — Download Customer Photos (`yumitori/etsy-customer-photo-scraper`) Actor

Download real Etsy customer review photos in bulk by keyword — each with its star rating, review text and date. Filter by date range, export to CSV/JSON/Excel. No API key, no login.

- **URL**: https://apify.com/yumitori/etsy-customer-photo-scraper.md
- **Developed by:** [Yakugusa Yumitori](https://apify.com/yumitori) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Download real **Etsy customer review photos** in bulk — just type a keyword. Etsy Review Photo Scraper crawls the top listings for any niche and pulls **every buyer-uploaded review photo** (with its star rating, review text, and date) into one clean dataset you can export to **CSV, JSON, Excel, or XML**. No API key, no login, no browser extension — the real, in-the-wild product imagery Etsy gives you no way to download in bulk.

Enter any keyword — say `necklace`, `leather wallet`, or `ceramic mug` — choose how many listings to crawl, and it starts collecting real buyer photos.

![Etsy Review Photo Scraper output table — real buyer review photos with thumbnails, star rating, review text, date, listing ID, language and keyword, exportable to CSV, JSON or Excel](https://files.catbox.moe/tkukkj.png)

### What can Etsy Review Photo Scraper do?

Etsy shoppers upload millions of review photos showing what they actually received — the true-to-life version of a product, not the seller's staged shot. Etsy has no "download all review photos" button and its official API won't hand you buyer photos, so this actor does it: as an **Etsy review scraper built for images**, it extracts every buyer **review photo** — the review images Etsy keeps locked away — in bulk, by keyword.

| 📦 What you can extract | ⚙️ Features & integrations |
|---|---|
| 📷 Buyer **review photos** (direct image URLs) from the top listings for any keyword | 🔎 Search **by keyword** across many shops at once |
| ⭐ **Star rating** for each photo's review | 📅 **Date-range** filter — pull any time window |
| 💬 Full **review text** attached to the photo | ⭐ **Minimum-rating** filter |
| 📅 **Review date** (`YYYY-MM-DD`) | ⬇️ Export to **JSON, CSV, Excel, XML** |
| 🏷️ **Listing ID** the photo belongs to | 🖼️ Optional: **download the actual image files** |
| 🌐 Review **language** | 🦾 **API, MCP**, Node.js & Python SDKs, scheduling |

Great for **UGC & social-proof sourcing, product and niche research, competitor analysis, dropshipping validation, quality/complaint analysis, moodboards, and image datasets for AI** — all from one keyword.

### What data you get

For any keyword, you get one row per **customer photo** — exportable to CSV, JSON, Excel, or XML:

| Field | Description |
|---|---|
| `image_url` | Direct URL to the buyer's review photo (public Etsy CDN — opens/downloads anywhere) |
| `rating` | Star rating of the review (1–5) |
| `review_text` | What the buyer wrote |
| `create_date` | Review date, `YYYY-MM-DD` |
| `listing_id` | The Etsy listing the photo belongs to |
| `language` | Detected review language |
| `keyword` | The search term that surfaced the listing |

**Photos only.** Every row is a review that includes a buyer image — text-only reviews aren't collected. Buyer identities (names, avatars, profile links) are intentionally **excluded**.

Why this fills a real gap: Etsy's official Open API is built for managing your **own** shop and is locked behind app registration and OAuth — it won't hand you **other shops'** buyer photos in bulk. This actor reads only **publicly visible** review data — no key, no OAuth, no shop ownership.

### How much does it cost?

**Pay-per-result — $7 per 1,000 photos.** You're billed per photo returned, never for runtime or empty results. Every Apify account includes **$5 in free credits** to start.

Why $7 when a generic Etsy scraper charges $3–5? Those tools return listing text and shop data — **none of them pull the buyer review photos.** This is the only actor that hands you real customer images in bulk.

| Charge | When | Price |
|---|---|---|
| **Photo** | Per photo returned (image URL + rating + review + date) | **$7.00 / 1,000** |
| **Image file** *(add-on)* | Only if you enable **Download image files** | **+ $3.00 / 1,000** |

The default — photo URLs plus review data — bills only the base **Photo** rate. Turning on **Download image files** adds the add-on, for **$10.00 / 1,000** all-in. Most users just take the free image URLs.

| Use case | Photos | Approx. cost |
|---|---|---|
| Quick sample | 300 | ~$2.10 |
| Niche moodboard | 2,000 | ~$14 |
| Full category sweep | 10,000 | ~$70 |

### How to use it

1. Open **Etsy Review Photo Scraper** in Apify Console and click **Try for free**.
2. Enter a **keyword** and adjust the optional filters (date range, minimum rating, how many listings, max photos).
3. Click **Save & Start**.
4. Download the results as **JSON, CSV, Excel, or XML** — or pull them via the API.

![Etsy Review Photo Scraper input form — enter a keyword (e.g. necklace), an optional review date range, number of listings to crawl, reviews scanned per listing, max photos, minimum star rating, and a Download image files toggle](https://files.catbox.moe/idetyt.png)

#### Inputs

| Parameter | Type | Default | Description |
|---|---|---|---|
| `keyword` | string | — | **Required.** The Etsy search term / niche to pull photos from. |
| `dateFrom` | string | — | Only keep reviews on/after this date (`YYYY-MM-DD`). |
| `dateTo` | string | — | Only keep reviews on/before this date (`YYYY-MM-DD`). |
| `maxListings` | integer | 100 | How many top listings to crawl. |
| `reviewsPerListing` | integer | 200 | How deep to scan each listing's reviews (newest-first). |
| `maxPhotos` | integer | 5000 | Hard cap on total photos for the run. |
| `minRating` | integer | 0 | Only keep photos from reviews at/above this star rating. |
| `downloadImages` | boolean | false | Also save the actual image files (adds the image-file charge). |

**Date range:** because reviews are read newest-first, the actor filters live and **stops scanning a listing the moment it drops below your start date** — so a "last 90 days" pull is fast. For older windows, raise `reviewsPerListing` so the crawl reaches far enough back.

**Input examples:**

```json
{ "keyword": "necklace", "maxListings": 100, "maxPhotos": 5000 }
````

```json
{ "keyword": "housewarming gift", "dateFrom": "2026-04-01", "dateTo": "2026-06-30", "minRating": 5, "maxListings": 150, "reviewsPerListing": 500 }
```

```json
{ "keyword": "leather wallet", "maxListings": 50, "maxPhotos": 2000, "downloadImages": true }
```

### Output

Results land in a dataset in the **Storage** tab — browse it as a table with photo thumbnails, download in **JSON, CSV, Excel, or XML**, or pull via API. The default view is pre-ordered, so your spreadsheet is clean the moment you open it.

```json
{
  "image_url": "https://i.etsystatic.com/iap/10477d/8153349738/iap_fullxfull.8153349738_70kemjew.jpg",
  "rating": 5,
  "review_text": "This is a beautiful pendant and the necklace is exactly as pictured. Shipped fast!",
  "create_date": "2026-06-18",
  "listing_id": 1348120443,
  "language": "en",
  "keyword": "necklace"
}
```

### What you can do with the photos

- **📣 UGC & social proof** — build a library of authentic customer photos for a category (run with `minRating: 5` + a recent `dateFrom`, sort by rating, and verify usage rights before republishing).
- **🔍 Product & niche research** — see what buyers actually receive across the top sellers before you sell or dropship; read the paired `review_text` for what they love or complain about.
- **⭐ Quality & complaint analysis** — filter the export to `rating` ≤ 2 to surface the damage, colour mismatches, and sizing issues buyers photograph.
- **🆚 Competitor benchmarking** — compare how rival products look in customers' hands, not just in staged listing shots.
- **🤖 AI image datasets** — labelled sets of photo + review text + rating for computer-vision or product models (pair with `downloadImages` and a schedule).

### How it compares

| Approach | Bulk photos? | API key / login? | Coding? | Cross-shop? |
|---|---|---|---|---|
| **This actor** | ✅ Thousands by keyword | ❌ None | ❌ No | ✅ Any niche |
| Etsy Open API | ❌ Not buyer photos | ✅ App + OAuth | ✅ Yes | ⚠️ Limited |
| Browser extension / manual | ❌ One at a time | ❌ | ❌ | ⚠️ Tedious |

### Integrations & automation

- **Google Sheets / Airtable** — push photo rows into a sheet and refresh on a schedule.
- **Make / Zapier / n8n** — trigger on run finish: filter by rating, drop image URLs into Slack or Notion.
- **Scheduler** — daily/weekly runs to keep a niche's customer-photo feed fresh.

### Using the API

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("yumitori/etsy-customer-photo-scraper").call(run_input={
    "keyword": "necklace", "maxListings": 100, "maxPhotos": 5000,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["image_url"], item["rating"], item["create_date"])
```

**cURL:**

```bash
curl -X POST "https://api.apify.com/v2/acts/yumitori~etsy-customer-photo-scraper/runs" \
  -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -d '{ "keyword": "necklace", "maxListings": 100, "maxPhotos": 5000 }'
```

**AI agents (MCP):** available as a tool for AI assistants that support the Model Context Protocol — so you can pull customer photos in plain English from Claude, Cursor, ChatGPT, and more.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=yumitori/etsy-customer-photo-scraper"
```

**Example prompts:**

- *"Pull 500 customer review photos for `ceramic mug` from the last 3 months and show me the 5-star ones."*
- *"Get the 1–2★ review photos for `resin coaster` so I can see what buyers complain about."*
- *"Grab 1,000 `dog bandana` customer photos and export them as a CSV."*
- *"Find recent buyer photos for `leather wallet` and summarize the common quality issues from the review text."*

### FAQ

**Do I need an Etsy API key or login?** No — no API key, no OAuth, no login, no captcha, no browser extension.

**How many customer review photos can I get?** Thousands per run. Raise `maxListings`, `reviewsPerListing`, and `maxPhotos` for deeper pulls; the actor paginates each listing's reviews to reach older photos.

**Does it include buyer names or personal info?** No. Buyer identities are intentionally excluded — only photos and review metadata.

**What's the difference between review photos and listing photos?** Listing photos are the seller's staged shots. **Review photos** are uploaded by real buyers showing what they actually received — more authentic, and exactly what this collects.

**Can I get only low-star (critical) review photos?** Yes — set `minRating`, or filter the exported `rating` column. Low-star photos are the fastest way to spot quality issues.

**How do I save the images as files?** The `image_url` fields point straight at the JPGs on Etsy's CDN — open or download them directly, or enable **Download image files** to save every photo to the run's storage at once.

**Will scraping Etsy get my IP blocked?** No — the actor runs entirely on Apify's infrastructure; you never use your own IP and there's nothing to install.

**Is it legal to scrape Etsy reviews?** These are **publicly visible** reviews, and the actor collects only that public data (with buyer identities excluded). Respect Etsy's Terms of Service, don't spam anyone, comply with GDPR/CCPA, and confirm rights before republishing customer photos. See Apify's guide to ethical web scraping.

**Is there a free Etsy review photo scraper?** Every Apify account includes free credits, so you can pull thousands of photos before paying anything.

**Getting an empty result?** Try a broader keyword (a plain search term, not a URL or shop name). If you set a narrow date range or high minimum rating, widen it.

### Related tools

Building a full Etsy research stack? Pair this with **[Etsy Listings Scraper](https://apify.com/yumitori/etsy-listings-scraper)** for product, price, and shop data by keyword.

***

> ⚠️ **Unofficial.** Not affiliated with, endorsed by, or sponsored by Etsy, Inc. "Etsy" is a trademark of Etsy, Inc., used here for descriptive purposes only. This actor collects only publicly visible review data and excludes buyer identities. Respect Etsy's Terms of Service and comply with GDPR/CCPA when handling any data.

# Actor input Schema

## `keyword` (type: `string`):

A plain Etsy search term — the same thing you'd type into Etsy's search bar. Single or multiple words both work. Examples: necklace · housewarming gift · leather wallet · ceramic mug · dog bandana · wall art. Use everyday product terms (not a URL or shop name) for the most photos.

## `dateFrom` (type: `string`):

Only keep reviews posted ON or AFTER this date (YYYY-MM-DD). Leave blank for no lower bound. Older windows may need a higher "reviews scanned per listing".

## `dateTo` (type: `string`):

Only keep reviews posted ON or BEFORE this date (YYYY-MM-DD). Leave blank for no upper bound.

## `maxListings` (type: `integer`):

How many of the top-ranked listings for the keyword to pull photos from.

## `reviewsPerListing` (type: `integer`):

How deep to scan each listing's reviews (newest-first). Without a date window this is the max photos per listing; with an older date window, raise it so the scan reaches back far enough.

## `maxPhotos` (type: `integer`):

Stop once this many photos have been collected across all listings.

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

Only keep photos from reviews at or above this rating (0 = all).

## `downloadImages` (type: `boolean`):

Also save the actual image files into the run's key-value store, not just the URLs. Adds a $3 per 1,000 add-on on top of the base per-photo price ($10 per 1,000 all-in). Leave off to pay only the base rate and use the image URLs directly.

## Actor input object example

```json
{
  "keyword": "necklace",
  "maxListings": 100,
  "reviewsPerListing": 200,
  "maxPhotos": 5000,
  "minRating": 0,
  "downloadImages": false
}
```

# 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 = {
    "keyword": "necklace"
};

// Run the Actor and wait for it to finish
const run = await client.actor("yumitori/etsy-customer-photo-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 = { "keyword": "necklace" }

# Run the Actor and wait for it to finish
run = client.actor("yumitori/etsy-customer-photo-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 '{
  "keyword": "necklace"
}' |
apify call yumitori/etsy-customer-photo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Etsy Review Photo Scraper — Download Customer Photos",
        "description": "Download real Etsy customer review photos in bulk by keyword — each with its star rating, review text and date. Filter by date range, export to CSV/JSON/Excel. No API key, no login.",
        "version": "0.1",
        "x-build-id": "W6sfKyOZK6Wm5qBfV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/yumitori~etsy-customer-photo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-yumitori-etsy-customer-photo-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/yumitori~etsy-customer-photo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-yumitori-etsy-customer-photo-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/yumitori~etsy-customer-photo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-yumitori-etsy-customer-photo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword / niche",
                        "type": "string",
                        "description": "A plain Etsy search term — the same thing you'd type into Etsy's search bar. Single or multiple words both work. Examples: necklace · housewarming gift · leather wallet · ceramic mug · dog bandana · wall art. Use everyday product terms (not a URL or shop name) for the most photos."
                    },
                    "dateFrom": {
                        "title": "Reviews from (date)",
                        "type": "string",
                        "description": "Only keep reviews posted ON or AFTER this date (YYYY-MM-DD). Leave blank for no lower bound. Older windows may need a higher \"reviews scanned per listing\"."
                    },
                    "dateTo": {
                        "title": "Reviews to (date)",
                        "type": "string",
                        "description": "Only keep reviews posted ON or BEFORE this date (YYYY-MM-DD). Leave blank for no upper bound."
                    },
                    "maxListings": {
                        "title": "Number of listings to crawl",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "How many of the top-ranked listings for the keyword to pull photos from.",
                        "default": 100
                    },
                    "reviewsPerListing": {
                        "title": "Reviews scanned per listing",
                        "minimum": 1,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "How deep to scan each listing's reviews (newest-first). Without a date window this is the max photos per listing; with an older date window, raise it so the scan reaches back far enough.",
                        "default": 200
                    },
                    "maxPhotos": {
                        "title": "Max photos (hard cap)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop once this many photos have been collected across all listings.",
                        "default": 5000
                    },
                    "minRating": {
                        "title": "Minimum star rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only keep photos from reviews at or above this rating (0 = all).",
                        "default": 0
                    },
                    "downloadImages": {
                        "title": "Download image files (extra charge)",
                        "type": "boolean",
                        "description": "Also save the actual image files into the run's key-value store, not just the URLs. Adds a $3 per 1,000 add-on on top of the base per-photo price ($10 per 1,000 all-in). Leave off to pay only the base rate and use the image URLs directly.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
