# Poshmark Sold Listings Scraper (`fetch_cat/poshmark-sold-listings-scraper`) Actor

Extract sold Poshmark comps with prices, brands, sizes, sellers, images, and item URLs for resale pricing research.

- **URL**: https://apify.com/fetch\_cat/poshmark-sold-listings-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Automation
- **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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Poshmark Sold Listings Scraper

Extract sold Poshmark listings for resale comps, pricing research, and ecommerce market analysis. Enter a keyword such as `nike shoes`, set a result limit, and get structured sold-listing records with prices, brands, sizes, sellers, images, and item URLs.

---

### 🔍 What does Poshmark Sold Listings Scraper do?

Poshmark Sold Listings Scraper collects public sold-listing results from Poshmark search pages and turns them into a clean dataset. Instead of manually opening pages and copying sold prices, you can run one actor and export the results to CSV, Excel, JSON, Google Sheets, or your own API pipeline.

Use it to answer questions like:

- ✅ What did similar items actually sell for?
- ✅ Which brands and sizes are moving in a niche?
- ✅ Which sellers are visible in recent sold results?
- ✅ How do sold prices compare with original list prices?
- ✅ Which listing titles and categories appear most often?

---

### 👥 Who is it for?

**Resellers and flippers** use the actor before buying inventory or pricing listings. Search a product name and review sold comps without copying data by hand.

**Ecommerce analysts** use it to monitor secondhand demand, compare resale price ranges, and build trend reports for brands, categories, or styles.

**Pricing teams** use sold listings as real-market evidence when deciding price bands for pre-owned apparel, shoes, accessories, and collectibles.

**Researchers and data teams** use the exported dataset for dashboards, enrichment, and historical market studies.

---

### 💡 Why use this actor?

Manual Poshmark research is slow. A single sold-comps workflow can involve searching, filtering, opening listings, recording prices, copying seller names, and cleaning everything in a spreadsheet.

This actor gives you:

- ⚡ Faster sold-comps collection
- 📦 Structured output ready for analysis
- 🧾 Listing IDs and URLs for traceability
- 💰 Sold price and original price fields
- 🧵 Brand, size, category, and department metadata
- 🖼️ Image URLs for visual review
- 🔁 Repeatable runs through the Apify API

---

### 📊 What data can you extract?

| Field | Description |
| --- | --- |
| `title` | Poshmark listing title |
| `url` | Public listing URL |
| `listingId` | Unique Poshmark listing identifier |
| `soldPrice` | Sold/listing price shown in the sold result |
| `currency` | Currency code, usually USD |
| `originalPrice` | Original/list price when available |
| `brand` | Brand name |
| `size` | Listing size |
| `category` | Category name |
| `department` | Department such as Women, Men, or Kids |
| `sellerUsername` | Seller handle when available |
| `sellerDisplayName` | Seller display name when available |
| `status` | Listing status |
| `inventoryStatus` | Inventory status, normally `sold_out` |
| `imageUrl` | Main listing image URL |
| `createdAt` | Listing creation timestamp when available |
| `updatedAt` | Listing update timestamp when available |
| `soldAt` | Sold/status timestamp when available |
| `sourceQuery` | Search query that produced the item |
| `scrapedAt` | Timestamp when the record was extracted |

---

### 💸 How much does it cost to scrape Poshmark sold listings?

The actor uses pay-per-event pricing. You pay a small start fee for each run and a per-result fee for each sold listing saved to the dataset.

Typical starter workflow:

- Start with 25-50 results for a pricing check.
- Increase to 100+ results when building a larger market report.
- Export the dataset only after the run finishes.

Paid Apify plans may receive tier discounts depending on the platform pricing tier. See the Pricing tab on the Apify Store page for the current live price.

---

### 🚀 How to use it

1. Open [Poshmark Sold Listings Scraper](https://apify.com/fetch_cat/poshmark-sold-listings-scraper).
2. Enter a search query, for example `lululemon leggings`.
3. Set **Maximum sold listings** to a small number for the first run.
4. Keep proxy disabled unless you see blocking.
5. Click **Start**.
6. Download the dataset as CSV, Excel, JSON, or connect it to your workflow.

---

### 🔎 Input options

#### Search query

Use a brand, model, item type, or phrase.

Examples:

- `nike dunk low`
- `lululemon align leggings`
- `coach tabby bag`
- `carhartt jacket`

#### Poshmark search URLs

If you already built a sold-listings URL on Poshmark, paste it into **Poshmark search URLs**. The actor can process the URL directly.

#### Maximum sold listings

Controls how many records are saved. Use a low value for quick tests and a higher value for research exports.

#### Sort order

Choose recently added, price high to low, price low to high, or most liked.

#### Proxy configuration

The actor normally works without a proxy for public searches. If Poshmark blocks a run from your environment, enable Apify Proxy and retry with a small result limit first.

---

### 📥 Example input

```json
{
  "query": "nike shoes",
  "maxItems": 25,
  "sortBy": "added_desc",
  "maxPages": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

***

### 📤 Example output

```json
{
  "title": "Nike Men's Light Gray Polo Shirt",
  "url": "https://poshmark.com/listing/Nike-Mens-Light-Gray-Polo-Shirt-...",
  "listingId": "683cfcb6...",
  "soldPrice": 5,
  "currency": "USD",
  "originalPrice": 0,
  "brand": "Nike",
  "size": "M",
  "category": "Shirts",
  "department": "Men",
  "sellerUsername": "example_seller",
  "inventoryStatus": "sold_out",
  "imageUrl": "https://di2ponv0v5otw.cloudfront.net/...jpg",
  "soldAt": "2026-06-11T02:34:51-07:00",
  "sourceQuery": "nike shoes",
  "scrapedAt": "2026-06-14T12:00:00.000Z"
}
```

***

### 🧠 Tips for better sold comps

- Use specific product names for tighter comps.
- Include model numbers when available.
- Compare several related searches instead of relying on one broad keyword.
- Start with 25 records, inspect quality, then scale up.
- Export CSV for quick spreadsheet analysis.
- Keep URLs in your dataset so you can audit examples later.

***

### 🔁 Common workflows

#### Resale pricing check

Search the exact item name, export 25-100 sold comps, remove outliers, and use the median sold price as a pricing anchor.

#### Brand demand report

Run weekly searches for a brand and track sold price ranges, categories, and sizes over time.

#### Inventory sourcing

Before buying a lot of used items, search likely product names and compare recent sold prices against your expected cost.

#### Market dashboard

Schedule recurring runs and send results into Google Sheets, BigQuery, Airtable, or a BI tool.

***

### 🧩 Integrations

Apify datasets can connect to many tools:

- Google Sheets for spreadsheet workflows
- Make or Zapier for no-code automations
- Airtable for lightweight databases
- BigQuery or Snowflake for analytics
- Webhooks for run-complete notifications
- API clients for custom apps

***

### 🛠️ API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/poshmark-sold-listings-scraper').call({
  query: 'nike shoes',
  maxItems: 25,
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_API_TOKEN')
run = client.actor('fetch_cat/poshmark-sold-listings-scraper').call({
    'query': 'nike shoes',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~poshmark-sold-listings-scraper/runs?token=YOUR_APIFY_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"nike shoes","maxItems":25}'
```

***

### 🤖 MCP usage

Use this actor from AI tools through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/poshmark-sold-listings-scraper
```

Example prompts:

- "Find 50 sold Poshmark comps for Nike Dunk Low and summarize the price range."
- "Scrape sold listings for Coach Tabby bag and identify common sizes/colors in the titles."
- "Run Poshmark sold comps for lululemon leggings and export the dataset URL."

***

### ⚖️ Legality: is it legal to scrape Poshmark sold listings?

This actor is designed for publicly available information. You are responsible for using the data lawfully, respecting applicable terms, and avoiding personal-data misuse. Do not use scraped data for spam, harassment, or decisions that require regulated data handling.

***

### ❓ FAQ

#### Does it require a Poshmark account?

No. It extracts public sold-search results that are visible without logging in.

#### Does it scrape active listings too?

This actor is focused on sold listings. Use a sold-listings URL or query and it requests sold-out availability.

#### Why did my run return fewer results than requested?

The source may have fewer matching sold listings, or Poshmark may stop pagination for that query. Try a broader keyword or increase the page cap.

#### Why are some fields empty?

Not every public search result includes every optional value. The actor keeps the record and fills unavailable fields with null.

#### Should I enable proxies?

Usually no. Enable Apify Proxy only if your run is blocked, and test with a small limit before scaling.

***

### 🧯 Troubleshooting

#### My query returns no data

Check the query on Poshmark manually and confirm sold results exist. Try a simpler phrase such as brand plus item type.

#### My run is slow

Large result limits require multiple search pages. Reduce `maxItems` for quick checks or keep `maxPages` moderate.

#### I need extra listing detail fields

This first version focuses on search-result fields. If you need detail-page enrichment, contact the actor owner or open a feature request.

***

### 🔐 Data quality notes

Sold prices and timestamps are taken from public listing/search result data. Marketplaces can change display formats, category labels, or pagination behavior. Keep important exports and rerun tests periodically for critical workflows.

***

### 📚 Related scrapers

Explore other Apify actors by fetch\_cat:

- [Cron Expression Parser](https://apify.com/fetch_cat/cron-expression-parser)
- [Dataset Dedup](https://apify.com/fetch_cat/dataset-dedup)
- [Website Change Monitor](https://apify.com/fetch_cat/website-change-monitor)

***

### 🧾 Changelog

#### 0.1

Initial version with keyword search, sold-listing pagination, structured output, optional search URLs, and optional proxy support.

***

### ✅ Summary

Poshmark Sold Listings Scraper helps resellers and analysts collect sold comps faster. Use it to research real sale prices, compare brands and sizes, and build repeatable resale market datasets without manual copy-paste.

# Actor input Schema

## `query` (type: `string`):

Keyword or phrase to search on Poshmark sold listings, such as a brand, model, or item type.

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

Optional public Poshmark search URLs. Use this when you already have a filtered sold-listings URL from Poshmark.

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

Maximum number of sold listing records to save.

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

Optional Poshmark sorting parameter for search pages.

## `maxPages` (type: `integer`):

Safety cap for pagination. Each Poshmark search page usually contains about 48 listings.

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

Optional proxy settings. The actor works without proxies for normal public searches; enable Apify Proxy only if Poshmark blocks your run.

## Actor input object example

```json
{
  "query": "nike shoes",
  "startUrls": [
    {
      "url": "https://poshmark.com/search?query=nike%20shoes&type=listings&availability=sold_out"
    }
  ],
  "maxItems": 20,
  "sortBy": "added_desc",
  "maxPages": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "query": "nike shoes",
    "startUrls": [
        {
            "url": "https://poshmark.com/search?query=nike%20shoes&type=listings&availability=sold_out"
        }
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/poshmark-sold-listings-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 = {
    "query": "nike shoes",
    "startUrls": [{ "url": "https://poshmark.com/search?query=nike%20shoes&type=listings&availability=sold_out" }],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/poshmark-sold-listings-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 '{
  "query": "nike shoes",
  "startUrls": [
    {
      "url": "https://poshmark.com/search?query=nike%20shoes&type=listings&availability=sold_out"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/poshmark-sold-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Poshmark Sold Listings Scraper",
        "description": "Extract sold Poshmark comps with prices, brands, sizes, sellers, images, and item URLs for resale pricing research.",
        "version": "0.1",
        "x-build-id": "sqH42cfHh9Qbalc7n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~poshmark-sold-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-poshmark-sold-listings-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/fetch_cat~poshmark-sold-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-poshmark-sold-listings-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/fetch_cat~poshmark-sold-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-poshmark-sold-listings-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword or phrase to search on Poshmark sold listings, such as a brand, model, or item type."
                    },
                    "startUrls": {
                        "title": "Poshmark search URLs",
                        "type": "array",
                        "description": "Optional public Poshmark search URLs. Use this when you already have a filtered sold-listings URL from Poshmark.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum sold listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of sold listing records to save.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "added_desc",
                            "price_desc",
                            "price_asc",
                            "like_count_desc"
                        ],
                        "type": "string",
                        "description": "Optional Poshmark sorting parameter for search pages.",
                        "default": "added_desc"
                    },
                    "maxPages": {
                        "title": "Maximum search pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for pagination. Each Poshmark search page usually contains about 48 listings.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. The actor works without proxies for normal public searches; enable Apify Proxy only if Poshmark blocks your run."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```