# Shein Search Products Scraper (`scraper-engine/shein-search-products-scraper`) Actor

🛍️ Scrape product data from Shein search results with ease. This Apify actor collects titles, prices, ratings, images, and URLs based on your keywords. Ideal for market research, price tracking, and competitor analysis with structured, export-ready data.

- **URL**: https://apify.com/scraper-engine/shein-search-products-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Shein Search Products Scraper

Shein Search Products Scraper is an Apify actor that collects structured product data from Shein search results based on your keywords. It solves the challenge of extracting titles, prices, ratings, and images at scale without manual browsing. Built for marketers, developers, data analysts, and researchers, this production-ready product search scraper enables market research, price tracking, and competitor analysis workflows with export-ready data.

### What data / output can you get?

The actor saves each product as a separate item in the Apify dataset, combining the raw Shein API product object with your search context.

| Data type | Description | Example value |
| --- | --- | --- |
| query | Search term that produced the product | "jacket" |
| country | Uppercase Shein market code | "US" |
| sort_order | Sort option used for the query | "recommend" |
| goods_id | Product identifier | "167962972" |
| goods_name | Product title | "Plus Size Blue Denim Casual Skinny Flare Jeans" |
| goods_img | Main image URL | "//img.ltwebstatic.com/..." |
| retailPrice | Original price object (amounts + symbols) | {"amount":"29.99","amountWithSymbol":"$29.99","usdAmount":"29.99","usdAmountWithSymbol":"$29.99"} |
| salePrice | Current sale price object (amounts + symbols) | {"amount":"23.99","amountWithSymbol":"$23.99","usdAmount":"23.99","usdAmountWithSymbol":"$23.99"} |
| detail_image | Product detail image(s) | "..." |
| productMaterial | Material details object | {...} |
| rankInfo | Ranking/engagement info | {...} |
| promotionInfo | Promotions info (if available) | {...} |

Notes:
- Additional fields from Shein’s API response are included as-is.
- Export your dataset in JSON or CSV from the Apify Console.

### Key features

- 🛡️ Robust proxy fallback
  Automatically escalates from no proxy to datacenter, then residential proxies if blocked (with up to 3 residential retries), improving reliability across regions.

- 🧠 Dynamic anti-bot headers
  Uses Playwright to visit Shein and capture required headers/tokens (e.g., armortoken and related headers) for stable API access.

- 📦 Live dataset saving
  Pushes each product row to the dataset as soon as it’s scraped, preserving partial results even if a run stops early.

- 📚 Bulk keyword support
  Provide multiple search terms to process in one run; each query is paginated until your maxItems limit is reached.

- 🔎 Sorting & filters
  Control sorting with orderBy and refine results using filter, categoryId, minPrice, maxPrice, page, and perPage settings.

- 🌍 Global coverage
  Target 38 Shein regional markets via countryCode for localized pricing and availability.

- 🐍 Developer-friendly stack
  Built with Python, Playwright, aiohttp, and Apify Actor SDK for reliability, observability, and easy extension.

### How to use Shein Search Products Scraper - step by step

1. Sign in to your Apify account at https://console.apify.com.
2. Open the Shein Search Products Scraper actor.
3. In the input form, add your keywords in query (e.g., jacket, dress, shoes). You can add multiple items.
4. Select countryCode for your target market (default: us). Adjust orderBy, page, perPage, and maxItems as needed.
5. Optional: Set filter, categoryId, minPrice, and maxPrice to refine results.
6. Optional: Configure proxyConfiguration. Leave it at the default (useApifyProxy: false) to start without a proxy.
7. Click Run. The actor will fetch dynamic headers, then start scraping and saving product rows as it progresses.
8. When complete, go to the Dataset tab to view results and export as JSON or CSV.

Pro tip: For larger runs or automation, orchestrate actor runs and download datasets via the Apify API.

### Use cases

| Use case name | Description |
| --- | --- |
| Price monitoring for e-commerce | Track salePrice and retailPrice over time to detect promotions and pricing strategies. |
| Catalog building for analytics | Aggregate goods_id, goods_name, images, and pricing to build comparison-ready catalogs. |
| Market research by region | Compare product availability and pricing across 38 countryCode markets for trend analysis. |
| Competitor assortment analysis | Analyze categories and promotions (promotionInfo) to benchmark assortment depth. |
| Data enrichment in pipelines | Feed structured product rows into your internal BI or data warehouse via Apify datasets/APIs. |
| Academic or trend research | Collect ranked products (rankInfo) for research on product popularity and consumer trends. |

### Why choose Shein Search Products Scraper?

Positioned for precision and reliability, this actor blends dynamic header acquisition with resilient networking to extract structured Shein product data at scale.

- ✅ Accurate results powered by dynamic headers captured via Playwright for stable API access.
- 🌍 38-country coverage using countryCode to localize results.
- 📦 Real-time dataset writes to safeguard partial progress.
- 📊 Sorting and filtering controls (orderBy, filter, categoryId, minPrice, maxPrice, page, perPage) for targeted extraction.
- 🧰 Developer-ready Python + Apify stack with clear logs and structured outputs.
- 🔁 Resilient proxy logic that escalates only when needed to balance speed and reliability.
- 🧱 Production-ready alternative to brittle browser extensions and manual copy-paste.

In short, it’s a purpose-built Shein product scraper designed for dependable, large-scale workflows.

### Is it legal / ethical to use Shein Search Products Scraper?

Yes — when used responsibly. This actor collects data from publicly available Shein search pages only and does not access private or password-protected content. You are responsible for:
- Complying with applicable regulations (e.g., GDPR, CCPA).
- Respecting website terms of service and usage policies.
- Using data ethically and for legitimate purposes.

If you have edge cases or jurisdiction-specific requirements, consult your legal team.

### Input parameters & output format

Example JSON input
```json
{
  "query": ["jacket", "jeans"],
  "countryCode": "us",
  "orderBy": "recommend",
  "maxItems": 300,
  "page": 1,
  "perPage": "120",
  "filter": "",
  "categoryId": "",
  "minPrice": "",
  "maxPrice": "",
  "proxyConfiguration": { "useApifyProxy": false }
}
````

Input fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| query | array | Yes | \["jacket"] | Product types to search (jacket, dress, shoes...). Add multiple items for separate searches. |
| countryCode | string | No | "us" | SHEIN regional site (e.g. US, UK, DE). |
| orderBy | string | No | "recommend" | How to sort the search results. One of: "recommend", "MostPopular", "NewArrivals", "TopRated", "PriceLowtoHigh", "PriceHightoLow". |
| maxItems | integer | No | 300 | Maximum products to scrape per search query (1–1000). |
| page | integer | No | 1 | Start page for pagination (1 = first page). |
| perPage | string | No | "120" | Number of products per page. One of: "20","40","60","80","100","120". |
| filter | string | No | "" | Extra filter options. Leave empty for no filter. |
| categoryId | string | No | "" | Filter by category. Leave empty for all categories. |
| minPrice | string | No | "" | Minimum price in local currency (e.g. 10). |
| maxPrice | string | No | "" | Maximum price in local currency (e.g. 100). |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Optional proxy for your run. Leave default for no proxy. |

Example JSON output (each item is one product row)

```json
[
  {
    "query": "jeans",
    "country": "US",
    "sort_order": "recommend",
    "goods_id": "167962972",
    "goods_name": "Plus Size Blue Denim Casual Skinny Flare Jeans",
    "goods_img": "//img.ltwebstatic.com/...",
    "retailPrice": {
      "amount": "29.99",
      "amountWithSymbol": "$29.99",
      "usdAmount": "29.99",
      "usdAmountWithSymbol": "$29.99"
    },
    "salePrice": {
      "amount": "23.99",
      "amountWithSymbol": "$23.99",
      "usdAmount": "23.99",
      "usdAmountWithSymbol": "$23.99"
    },
    "detail_image": "...",
    "productMaterial": { },
    "rankInfo": { },
    "promotionInfo": { }
  },
  {
    "query": "jacket",
    "country": "US",
    "sort_order": "recommend",
    "goods_id": "123456789",
    "goods_name": "Waterproof Hooded Windbreaker",
    "goods_img": "//img.ltwebstatic.com/...",
    "retailPrice": {
      "amount": "49.99",
      "amountWithSymbol": "$49.99",
      "usdAmount": "49.99",
      "usdAmountWithSymbol": "$49.99"
    },
    "salePrice": {
      "amount": "39.99",
      "amountWithSymbol": "$39.99",
      "usdAmount": "39.99",
      "usdAmountWithSymbol": "$39.99"
    },
    "detail_image": "...",
    "productMaterial": { },
    "rankInfo": { },
    "promotionInfo": { }
  }
]
```

Notes:

- The actor pushes one dataset item per product with contextual fields: query, country, sort\_order.
- Product fields come directly from Shein’s API response and may vary by product; some sub-objects can be empty if data is unavailable.

### FAQ

#### Do I need a proxy to run this scraper?

No. The actor starts without a proxy for speed and cost efficiency. If requests are blocked, it automatically escalates to datacenter and then to residential proxies with up to 3 retries.

#### Can I target multiple countries?

Yes. Set countryCode to any of the supported Shein markets (default is "us") to localize results.

#### How many products can I scrape per keyword?

Up to 1000 per query via maxItems. The default is 300, and pagination proceeds until the limit is reached or results end.

#### Can I sort and filter the results?

Yes. Use orderBy for sorting and filter/categoryId/minPrice/maxPrice/page/perPage to refine and control pagination.

#### What data is saved to the dataset?

Each result is a single product row containing all fields returned by the Shein API (e.g., goods\_id, goods\_name, salePrice, retailPrice) plus query, country, and sort\_order.

#### What happens if the run is interrupted?

Products are pushed as they’re scraped, so partial results are preserved in the dataset even if a run stops early.

#### Do I need to log in to Shein?

No. The actor does not require login. It uses Playwright to obtain necessary request headers/tokens for public API access.

#### How can I export the results?

Open the run’s Dataset in Apify and export to JSON or CSV. You can also access the dataset programmatically via Apify.

### Closing CTA / Final thoughts

Shein Search Products Scraper is built to reliably extract structured product data from Shein search results at scale. With dynamic header handling, smart proxy fallback, and live dataset writes, it streamlines price tracking, cataloging, and market research for marketers, analysts, and developers. Use the flexible inputs (sorting, filters, pagination) to tailor results to your needs, and integrate outputs into your workflows via Apify datasets. Start extracting smarter product insights today.

# Actor input Schema

## `query` (type: `array`):

Product types to search (jacket, dress, shoes...). Add multiple items for separate searches.

## `countryCode` (type: `string`):

SHEIN regional site (e.g. US, UK, DE)

## `orderBy` (type: `string`):

How to sort the search results

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

Maximum products to scrape per search query (1–1000)

## `page` (type: `integer`):

Start page for pagination (1 = first page)

## `perPage` (type: `string`):

Number of products per page (20–120)

## `filter` (type: `string`):

Extra filter options. Leave empty for no filter.

## `categoryId` (type: `string`):

Filter by category. Leave empty for all categories.

## `minPrice` (type: `string`):

Minimum price in local currency (e.g. 10)

## `maxPrice` (type: `string`):

Maximum price in local currency (e.g. 100)

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

Optional proxy for your run. Leave default for no proxy.

## Actor input object example

```json
{
  "query": [
    "jacket"
  ],
  "countryCode": "us",
  "orderBy": "recommend",
  "maxItems": 300,
  "page": 1,
  "perPage": "120",
  "filter": "",
  "categoryId": "",
  "minPrice": "",
  "maxPrice": "",
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "query": [
        "jacket"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/shein-search-products-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": ["jacket"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/shein-search-products-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": [
    "jacket"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/shein-search-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shein Search Products Scraper",
        "description": "🛍️ Scrape product data from Shein search results with ease. This Apify actor collects titles, prices, ratings, images, and URLs based on your keywords. Ideal for market research, price tracking, and competitor analysis with structured, export-ready data.",
        "version": "0.1",
        "x-build-id": "RaENlC9wTDqyvQIVb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~shein-search-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-shein-search-products-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/scraper-engine~shein-search-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-shein-search-products-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/scraper-engine~shein-search-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-shein-search-products-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "🔍 Search Query",
                        "type": "array",
                        "description": "Product types to search (jacket, dress, shoes...). Add multiple items for separate searches.",
                        "default": [
                            "jacket"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryCode": {
                        "title": "🌍 Country",
                        "enum": [
                            "us",
                            "de",
                            "fr",
                            "it",
                            "ch",
                            "pl",
                            "pt",
                            "es",
                            "se",
                            "uk",
                            "ca",
                            "mx",
                            "br",
                            "ae",
                            "sa",
                            "ru",
                            "jp",
                            "kr",
                            "cn",
                            "tw",
                            "hk",
                            "au",
                            "in",
                            "id",
                            "ph",
                            "my",
                            "sg",
                            "tr",
                            "nl",
                            "be",
                            "at",
                            "dk",
                            "no",
                            "fi",
                            "ie",
                            "vn",
                            "th",
                            "il"
                        ],
                        "type": "string",
                        "description": "SHEIN regional site (e.g. US, UK, DE)",
                        "default": "us"
                    },
                    "orderBy": {
                        "title": "↕️ Sort Order",
                        "enum": [
                            "recommend",
                            "MostPopular",
                            "NewArrivals",
                            "TopRated",
                            "PriceLowtoHigh",
                            "PriceHightoLow"
                        ],
                        "type": "string",
                        "description": "How to sort the search results",
                        "default": "recommend"
                    },
                    "maxItems": {
                        "title": "🎯 Max Items Per Query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum products to scrape per search query (1–1000)",
                        "default": 300
                    },
                    "page": {
                        "title": "📄 Page Number",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Start page for pagination (1 = first page)",
                        "default": 1
                    },
                    "perPage": {
                        "title": "📦 Items Per Page",
                        "enum": [
                            "20",
                            "40",
                            "60",
                            "80",
                            "100",
                            "120"
                        ],
                        "type": "string",
                        "description": "Number of products per page (20–120)",
                        "default": "120"
                    },
                    "filter": {
                        "title": "🔧 Additional Filters",
                        "type": "string",
                        "description": "Extra filter options. Leave empty for no filter.",
                        "default": ""
                    },
                    "categoryId": {
                        "title": "📂 Category ID",
                        "type": "string",
                        "description": "Filter by category. Leave empty for all categories.",
                        "default": ""
                    },
                    "minPrice": {
                        "title": "💰 Min Price",
                        "type": "string",
                        "description": "Minimum price in local currency (e.g. 10)",
                        "default": ""
                    },
                    "maxPrice": {
                        "title": "💰 Max Price",
                        "type": "string",
                        "description": "Maximum price in local currency (e.g. 100)",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy for your run. Leave default for no proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
