# Poshmark Product & Listing Scraper (`scrapeworks/poshmark-product-scraper`) Actor

Scrape Poshmark listings in bulk by keyword, brand, category or seller closet. Export price, original price, brand, size, condition, colors, photos, seller and sold-price data as clean JSON. No login or API key required.

- **URL**: https://apify.com/scrapeworks/poshmark-product-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Poshmark Product & Listing Scraper

Extract **Poshmark product listings in bulk** - by keyword, brand, category, or an entire seller's closet - as clean, structured JSON. No login, no API key. Perfect for resellers, price research, brand monitoring, dropshipping/sourcing, and market analytics on the social resale marketplace.

Give it a list of search queries (or paste Poshmark URLs) and it paginates each one **deep** - up to Poshmark's 5,000-listings-per-search ceiling - returning one tidy row per listing with price, brand, size, condition, colors, photos, seller and engagement stats.

---

### What you can scrape

- **Keyword search** - e.g. `nike air max`, `lululemon leggings`, `coach bag`. Run many queries in one go.
- **Brand catalogs** - every listing for a brand (e.g. all `Nike` in `Men`), no keyword needed.
- **Category pages** - paste a Poshmark category URL.
- **Closets (a whole seller's inventory)** - paste `https://poshmark.com/closet/USERNAME` to pull everything that seller lists. Give it a list of usernames to scrape many sellers at once.
- **Sold listings** - flip the *Availability* filter to **Sold** to see what items actually sold for (gold for pricing research).

Filter by **department, brand, size, color, condition (New With Tags), availability** and **sort** by newest or price.

---

### What you get - output fields

Every row is one listing:

| Field | Description |
|---|---|
| `id` | Poshmark listing ID |
| `title` | Listing title |
| `url` | Direct link to the listing |
| `price` | Current asking price (number) |
| `originalPrice` | Seller's original/retail price, if set |
| `currency` | Currency code, e.g. `USD` |
| `priceDropPercentage` | Price-drop % badge, if any |
| `brand` | Brand |
| `size` / `sizeWithSystem` | Size (e.g. `M`, `9`) and with system (e.g. `US 9`) |
| `department` | Women / Men / Kids / Home / Pets / Electronics |
| `category` | Item category, e.g. `Shoes`, `Dresses` |
| `condition` / `conditionCode` / `isNwt` | `New With Tags` / `Like New` / `Good` / `Fair`; raw code; and a New-With-Tags flag |
| `colors` | List of colors |
| `inventoryStatus` / `isAvailable` / `isSold` | `available` or `sold_out`, plus booleans |
| `sellerUsername` / `sellerName` | The seller |
| `likeCount` / `shareCount` / `commentCount` | Engagement stats |
| `activeBuyerOffers` | Number of active buyer offers |
| `description` | Full item description |
| `coverPhoto` / `photos` / `photoCount` | Cover image URL, all image URLs, and count |
| `createdAt` / `firstPublishedAt` / `updatedAt` | Listing timestamps |
| `searchQuery` / `sourceUrl` / `scrapedAt` | Which query/URL surfaced it, and when |

#### Example output

```json
{
  "id": "6a3af2c9dc3b4639ba5146b7",
  "title": "Nike KillShot shoes",
  "url": "https://poshmark.com/listing/Nike-KillShot-shoes-6a3af2c9dc3b4639ba5146b7",
  "price": 15.0,
  "originalPrice": null,
  "currency": "USD",
  "priceDropPercentage": 25,
  "brand": "Nike",
  "size": "8.5",
  "sizeWithSystem": "US 8.5",
  "department": "Women",
  "category": "Shoes",
  "condition": "Fair",
  "conditionCode": "uf",
  "isNwt": false,
  "colors": ["Blue", "White"],
  "inventoryStatus": "available",
  "isAvailable": true,
  "isSold": false,
  "sellerUsername": "ab411",
  "sellerName": "Allie b",
  "likeCount": 6,
  "shareCount": 4,
  "commentCount": 0,
  "coverPhoto": "https://di2ponv0v5otw.cloudfront.net/posts/.../l_....jpg",
  "photos": ["https://di2ponv0v5otw.cloudfront.net/posts/.../l_....jpg"],
  "photoCount": 7,
  "createdAt": "2026-06-23T13:55:37-07:00",
  "searchQuery": "nike air max",
  "sourceUrl": "https://poshmark.com/search?query=nike+air+max&type=listings",
  "scrapedAt": "2026-07-26T18:00:00+00:00"
}
````

***

### Example input

```json
{
  "searchQueries": ["nike air max", "lululemon leggings"],
  "department": "Women",
  "availability": "available",
  "sortBy": "best_match",
  "maxItemsPerQuery": 500,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

Scrape a **brand's whole catalog** (no keyword):

```json
{ "brand": "Coach", "department": "Women", "maxItemsPerQuery": 2000 }
```

Scrape **several sellers' full closets**:

```json
{ "startUrls": [
    "https://poshmark.com/closet/ashleyriehl",
    "https://poshmark.com/closet/kirbydivers"
] }
```

Do **sold-price research** for a brand:

```json
{ "searchQueries": ["jordan 1"], "availability": "sold", "sortBy": "added_desc", "maxItemsPerQuery": 1000 }
```

***

### Input options

- **searchQueries** - list of keyword searches. Each is paginated deep.
- **startUrls** - list of Poshmark search / brand / category / closet URLs.
- **department** - Women, Men, Kids, Home, Pets, Electronics (or any).
- **brand** - single brand to filter by (or browse a brand with no keyword).
- **sizes** - list of sizes (e.g. `M`, `9.5`, `32`).
- **colors** - list from Poshmark's 15 colors (Black, Blue, Red, ...).
- **condition** - Any or New With Tags only.
- **availability** - Available, Sold, or All.
- **sortBy** - Best Match, Just In, Price Low→High, Price High→Low.
- **maxItemsPerQuery** - cap per source (up to 5,000).
- **maxItems** - optional overall cap across all sources.
- **proxyConfiguration** - Apify Proxy (automatic by default).

***

### How it works & notes

- Poshmark serves fully rendered pages that embed the complete listing data as JSON (`__INITIAL_STATE__`), so the actor reads **structured machine data**, not brittle HTML - each row is stable and clean.
- **Deep pagination** uses Poshmark's own cursor, 48 listings per page. A single Poshmark search is capped by Poshmark itself at ~5,000 results, so to pull a huge niche, split it across several queries, brands, sizes, or category/closet URLs.
- Listings are **de-duplicated by ID** across your whole run, so you are never billed twice for the same item.
- `originalPrice`, `priceDropPercentage`, `likeCount` and `colors` are only present when the seller set them - an empty value is a real gap in that listing, not a scraping error. `description` is the full seller-written text.
- The actor reaches Poshmark through Apify Proxy and automatically rotates the proxy session and retries if a page is ever blocked.

### Pricing

This actor bills **pay per result**: you are charged once for each listing returned. Blocked or empty pages are never charged.

### FAQ

**Do I need a Poshmark account or API key?** No. Everything is scraped from public pages.

**Can I get sold prices?** Yes - set *Availability* to **Sold**. Great for figuring out what an item actually sells for before you list or buy.

**Can I scrape a specific seller's whole closet?** Yes - paste `https://poshmark.com/closet/USERNAME` into Start URLs. Add as many sellers as you like.

**How many listings can I get per search?** Poshmark caps a single search at ~5,000. Use multiple queries/brands/sizes/URLs to go beyond that.

**Is this legal?** The actor collects only publicly available data. You are responsible for using scraped data in line with Poshmark's terms and applicable laws.

***

*Not affiliated with, endorsed by, or sponsored by Poshmark. "Poshmark" is a trademark of its respective owner and is used here only to describe what this tool scrapes.*

# Actor input Schema

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

One or more things to search for on Poshmark - e.g. 'nike air max', 'lululemon leggings', 'coach bag', 'vintage levis'. Each query is run as its own Poshmark search with the filters below applied, and paginated deep (48 listings per page). Results are billed per listing, so more queries = more rows. Leave empty if you are browsing by brand/department only or pasting Start URLs below.

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

Optional: paste full Poshmark URLs to scrape directly. Works for search pages (https://poshmark.com/search?query=...), brand pages (https://poshmark.com/brand/Nike-Women-Shoes), category pages (https://poshmark.com/category/Women-Shoes) and closets - a seller's whole inventory (https://poshmark.com/closet/USERNAME). Each URL is paginated deep, just like a query. Great for scraping a list of sellers or applying Poshmark's own on-site filters.

## `department` (type: `string`):

Narrow every search query to one department. Leave as 'Any' to include all. (Applies to Search queries, not to pasted Start URLs, which carry their own filters.)

## `brand` (type: `string`):

Narrow every search query to a single brand as it appears on Poshmark, e.g. 'Nike', 'Lululemon', 'Coach', 'Free People'. You can also leave Search queries empty and set only a brand to scrape that brand's whole catalog.

## `sizes` (type: `array`):

Optional size filter, e.g. 'M', 'XL', '8', '9.5', '32'. Any listing matching one of these sizes is included. Use the size token exactly as Poshmark shows it (clothing letters, shoe/waist numbers).

## `colors` (type: `array`):

Optional color filter. Poshmark's 15 colors: Red, Pink, Orange, Yellow, Green, Blue, Purple, Gold, Silver, Black, Gray, White, Cream, Brown, Tan. Any listing matching one of these colors is included.

## `condition` (type: `string`):

Filter by condition. 'Any' returns everything; 'New With Tags only' returns only brand-new tagged items.

## `availability` (type: `string`):

'Available' returns live listings you can buy (default). 'Sold' returns sold listings - useful for reseller price research (what items actually sold for). 'All' returns both.

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

Order results within each search. Best Match is Poshmark's default relevance ranking.

## `maxItemsPerQuery` (type: `integer`):

Maximum listings to return for EACH search query / brand browse / Start URL. The actor paginates automatically (48 per page). Poshmark caps a single search at 5,000 listings, so 5000 pulls everything available for that search; a closet returns up to that seller's whole inventory.

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

Optional hard cap on the total number of listings across ALL sources combined. Leave empty for no overall cap (each source still stops at 'Max listings per source').

## `proxyConfiguration` (type: `object`):

Proxy used to reach poshmark.com. The default (Apify Proxy, automatic) works well - Poshmark serves fully rendered pages to datacenter traffic. Switch to Residential if you scrape very heavily and start seeing blocks; the actor automatically rotates the proxy session on any block.

## Actor input object example

```json
{
  "searchQueries": [
    "nike air max",
    "lululemon leggings",
    "coach bag"
  ],
  "startUrls": [
    "https://poshmark.com/closet/ashleyriehl",
    "https://poshmark.com/brand/Nike-Women-Shoes"
  ],
  "department": "",
  "brand": "Nike",
  "sizes": [
    "M",
    "L"
  ],
  "colors": [
    "Black"
  ],
  "condition": "any",
  "availability": "available",
  "sortBy": "best_match",
  "maxItemsPerQuery": 500,
  "proxyConfiguration": {
    "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 = {
    "searchQueries": [
        "nike air max"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchQueries": ["nike air max"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/poshmark-product-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "nike air max"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapeworks/poshmark-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Poshmark Product & Listing Scraper",
        "description": "Scrape Poshmark listings in bulk by keyword, brand, category or seller closet. Export price, original price, brand, size, condition, colors, photos, seller and sold-price data as clean JSON. No login or API key required.",
        "version": "0.1",
        "x-build-id": "5k0i4ZjPl8xVGrSVh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~poshmark-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-poshmark-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapeworks~poshmark-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-poshmark-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapeworks~poshmark-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-poshmark-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more things to search for on Poshmark - e.g. 'nike air max', 'lululemon leggings', 'coach bag', 'vintage levis'. Each query is run as its own Poshmark search with the filters below applied, and paginated deep (48 listings per page). Results are billed per listing, so more queries = more rows. Leave empty if you are browsing by brand/department only or pasting Start URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (search, brand, category or closet pages)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional: paste full Poshmark URLs to scrape directly. Works for search pages (https://poshmark.com/search?query=...), brand pages (https://poshmark.com/brand/Nike-Women-Shoes), category pages (https://poshmark.com/category/Women-Shoes) and closets - a seller's whole inventory (https://poshmark.com/closet/USERNAME). Each URL is paginated deep, just like a query. Great for scraping a list of sellers or applying Poshmark's own on-site filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "department": {
                        "title": "Department",
                        "enum": [
                            "",
                            "Women",
                            "Men",
                            "Kids",
                            "Home",
                            "Pets",
                            "Electronics"
                        ],
                        "type": "string",
                        "description": "Narrow every search query to one department. Leave as 'Any' to include all. (Applies to Search queries, not to pasted Start URLs, which carry their own filters.)",
                        "default": ""
                    },
                    "brand": {
                        "title": "Brand",
                        "type": "string",
                        "description": "Narrow every search query to a single brand as it appears on Poshmark, e.g. 'Nike', 'Lululemon', 'Coach', 'Free People'. You can also leave Search queries empty and set only a brand to scrape that brand's whole catalog."
                    },
                    "sizes": {
                        "title": "Sizes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional size filter, e.g. 'M', 'XL', '8', '9.5', '32'. Any listing matching one of these sizes is included. Use the size token exactly as Poshmark shows it (clothing letters, shoe/waist numbers).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "colors": {
                        "title": "Colors",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional color filter. Poshmark's 15 colors: Red, Pink, Orange, Yellow, Green, Blue, Purple, Gold, Silver, Black, Gray, White, Cream, Brown, Tan. Any listing matching one of these colors is included.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "any",
                            "nwt"
                        ],
                        "type": "string",
                        "description": "Filter by condition. 'Any' returns everything; 'New With Tags only' returns only brand-new tagged items.",
                        "default": "any"
                    },
                    "availability": {
                        "title": "Availability",
                        "enum": [
                            "available",
                            "sold",
                            "all"
                        ],
                        "type": "string",
                        "description": "'Available' returns live listings you can buy (default). 'Sold' returns sold listings - useful for reseller price research (what items actually sold for). 'All' returns both.",
                        "default": "available"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "best_match",
                            "added_desc",
                            "price_asc",
                            "price_desc"
                        ],
                        "type": "string",
                        "description": "Order results within each search. Best Match is Poshmark's default relevance ranking.",
                        "default": "best_match"
                    },
                    "maxItemsPerQuery": {
                        "title": "Max listings per source",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum listings to return for EACH search query / brand browse / Start URL. The actor paginates automatically (48 per page). Poshmark caps a single search at 5,000 listings, so 5000 pulls everything available for that search; a closet returns up to that seller's whole inventory.",
                        "default": 500
                    },
                    "maxItems": {
                        "title": "Max listings overall (optional)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional hard cap on the total number of listings across ALL sources combined. Leave empty for no overall cap (each source still stops at 'Max listings per source')."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach poshmark.com. The default (Apify Proxy, automatic) works well - Poshmark serves fully rendered pages to datacenter traffic. Switch to Residential if you scrape very heavily and start seeing blocks; the actor automatically rotates the proxy session on any block.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
