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

🛍️ Search & scrape Shein product data from 38 countries. 🔍 Keywords, filters, price range & sort options. 📦 Output: titles, prices, images, ratings & more.

- **URL**: https://apify.com/scrapier/shein-search-products-scraper.md
- **Developed by:** [Scrapier](https://apify.com/scrapier) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 4 total users, 3 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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 Shein search result data at scale from 38 regional sites. It works as a Shein product search scraper and Shein search results scraper that extracts structured product listings (titles, prices, images, ratings, and more) for marketers, developers, data analysts, and researchers. Use this Shein search products scraping tool as a production-ready Shein search products API alternative to power catalog enrichment, price tracking, and market analysis at scale. 🚀

### What data / output can you get?

Below are the primary fields you’ll see in the dataset. Each row represents a single product enriched with context about the search that produced it.

| Data field | Description | Example value |
| --- | --- | --- |
| query | The search keyword used to find the product | "jacket" |
| country | Uppercase country code of the Shein regional site | "US" |
| sort_order | Sort option applied to the search | "recommend" |
| goods_id | Shein product ID | "167962972" |
| goods_name | Product title/name | "Plus Size Blue Denim Casual Skinny Flare Jeans" |
| goods_img | Main image URL | "//img.ltwebstatic.com/images3_pi/..." |
| retailPrice | Regular/retail price object | {"amount":"29.99","amountWithSymbol":"$29.99"} |
| salePrice | Current/sale price object | {"amount":"23.99","amountWithSymbol":"$23.99"} |
| detail_image | Product detail image URL | "https://img.ltwebstatic.com/images3_pi/..." |
| productMaterial | Material/details object from Shein API | { ... } |
| rankInfo | Ranking/score metadata from Shein API | { ... } |
| promotionInfo | Promotion/discount metadata | { ... } |

Notes:
- The actor streams products to the Apify dataset as they are scraped. You can export results to JSON, CSV, or Excel from the dataset UI.
- In addition to query, country, and sort_order, each row includes the full product object returned by the Shein API (keys may vary by region/category).

### Key features

- 🔒 Robust proxy fallback
  Automatically escalates from no proxy ➜ datacenter ➜ residential (3 retries) if requests get blocked. Once residential succeeds, it continues with it for the remainder of the run.

- 🧠 Dynamic header extraction
  Uses Playwright to fetch anti-bot headers and cookies (e.g., armortoken) directly from live pages for reliable API access.

- 📦 Batch keywords & high throughput
  Add multiple keywords to the query list and scrape Shein product listings at scale across regions and categories.

- 🌍 38-country support + flexible sorting
  Target Shein markets like us, uk, de, fr, es, ca, br, au, sg, and more. Sort by Recommended, MostPopular, NewArrivals, TopRated, or price.

- 🎯 Precise filters & pagination
  Control max items, page start, items per page, categoryId, minPrice/maxPrice, and attribute-based filters for targeted datasets.

- 💾 Live dataset streaming
  Results are pushed continuously via Actor.push_data, so partial data is preserved even if a run stops.

- 🧑‍💻 Developer-friendly automations
  Integrate via the Apify API and SDK from your stack (e.g., use this as a Shein product data extractor in Python workflows) to build repeatable pipelines and export Shein search results to CSV.

- 🛠️ Production-ready reliability
  Clear progress logs, resilient retries, and structured requests ensure consistent data for Shein web scraper for products workflows.

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

1. Sign in to your Apify account (free to start) and open the Shein Search Products Scraper actor.
2. In the Input tab, add your keywords under “Search Query” (query). You can add multiple items to run separate searches in one job.
3. Choose a target “Country” (countryCode). Default is "us" but 38 markets are supported.
4. Configure sorting (orderBy) and limits:
   - maxItems (1–1000), page (start page), perPage (20–120 as a string).
5. Apply optional filters:
   - categoryId, minPrice, maxPrice, and filter (attribute_ids) for attribute-level filtering.
6. (Optional) Set proxyConfiguration. Leaving it off starts with no proxy; the actor will automatically fall back to datacenter and then residential if needed.
7. Click Start to run. You’ll see logs with progress, keyword counts, and saved products.
8. When finished, open the Dataset tab to preview results and export to JSON/CSV/Excel.

Pro Tip: Use the Apify API to trigger runs and pull dataset results into your internal data pipelines or a Shein product scraper Python script for automated catalog updates.

### Use cases

| Use case name | Description |
| --- | --- |
| Ecommerce price monitoring | Track product pricing across regions and categories to inform promotions and margin strategy. |
| Catalog enrichment for marketplaces | Aggregate product titles, images, and pricing to build comparable datasets for your storefront or analytics hub. |
| Merchandising & SEO research | Analyze top-ranked, most popular, and new arrival listings to inform keyword targeting and content strategy. |
| Competitive benchmarking | Compare categories and pricing across countries for strategic planning and assortment decisions. |
| Trend & inventory scouting | Collect product listings over time to spot trends in styles, categories, and promotional patterns. |
| Data pipeline & API workflows | Orchestrate scheduled runs with the Apify API and export results to CSV/JSON for BI tools, warehouses, or apps. |

### Why choose Shein Search Products Scraper?

Built for accuracy, scale, and automation, this scraper addresses reliability challenges that plague browser extensions and unstable scripts.

- ✅ Accurate & resilient: Dynamic header capture (armortoken and more) enables stable API calls.
- 🌍 Global-ready: Works across 38 Shein markets with consistent request handling.
- 📈 Scalable scraping: Batch multiple keywords and control pagination/limits for large datasets.
- 🧑‍💻 Developer access: Integrate via the Apify API or SDK in your preferred stack.
- 🔐 Ethical by design: Targets publicly available search endpoints without login.
- 💰 Cost-conscious: Starts without a proxy and escalates only if blocked to optimize cost and speed.
- 🧱 Robust infrastructure: Automatic proxy fallback (datacenter ➜ residential with 3 retries) for production reliability.

In short, it’s a production-grade Shein product listings scraper you can trust for repeatable data extraction.

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

Yes—when used responsibly. This actor collects data from public Shein search pages and does not access private or password-protected content.

Guidelines for compliant use:
- Scrape only publicly available data.
- Review and respect applicable terms of service.
- Ensure compliance with data regulations (e.g., GDPR, CCPA) in your jurisdiction.
- Consult your legal team for edge cases or commercial redistribution use.

### Input parameters & output format

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

Input field reference

- query (array, required): Product types to search (e.g., jacket, dress, shoes). Add multiple items for separate searches. Default: \["jacket"].
- countryCode (string, optional): SHEIN regional site (e.g., us, uk, de). Default: "us".
- orderBy (string, optional): Sorting for the results. One of \["recommend","MostPopular","NewArrivals","TopRated","PriceLowtoHigh","PriceHightoLow"]. Default: "recommend".
- maxItems (integer, optional): Maximum products to scrape per search query (1–1000). Default: 300.
- page (integer, optional): Start page for pagination (1 = first page). Default: 1.
- perPage (string, optional): Number of products per page. One of \["20","40","60","80","100","120"]. Default: "120".
- filter (string, optional): Extra filter options (mapped to attribute\_ids). Default: "".
- categoryId (string, optional): Filter by category ID. Default: "".
- minPrice (string, optional): Minimum price in local currency (e.g., "10"). Default: "".
- maxPrice (string, optional): Maximum price in local currency (e.g., "100"). Default: "".
- proxyConfiguration (object, optional): Optional proxy configuration. Default prefill: {"useApifyProxy": false}.

Example JSON output

```json
[
  {
    "query": "jacket",
    "country": "US",
    "sort_order": "recommend",
    "goods_id": "167962972",
    "goods_name": "Plus Size Blue Denim Casual Skinny Flare Jeans",
    "goods_img": "//img.ltwebstatic.com/images3_pi/2023/12/...",
    "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": "https://img.ltwebstatic.com/images3_pi/2023/12/...",
    "productMaterial": {
      "composition": "Cotton/Polyester"
    },
    "rankInfo": {
      "score": 98
    },
    "promotionInfo": {
      "label": "SALE"
    }
  },
  {
    "query": "dress",
    "country": "US",
    "sort_order": "recommend",
    "goods_id": "123456789",
    "goods_name": "Floral Print Summer Dress",
    "goods_img": "//img.ltwebstatic.com/images3_pi/2024/02/...",
    "retailPrice": {
      "amount": "19.99",
      "amountWithSymbol": "$19.99"
    },
    "salePrice": {
      "amount": "15.99",
      "amountWithSymbol": "$15.99"
    }
  }
]
```

Notes:

- Each dataset row is pushed with fields: query, country, sort\_order, plus all fields returned by Shein’s product API for that item.
- Some fields (e.g., promotionInfo, productMaterial, rankInfo) may be absent for certain products depending on availability.

### FAQ

#### Does this require login or cookies?

No. The scraper targets public Shein search endpoints and does not require login. It uses Playwright to obtain necessary anti-bot headers for reliable access.

#### Which countries are supported?

The input supports 38 markets via countryCode, including us, uk, de, fr, it, es, ca, mx, br, ae, sa, jp, kr, cn, tw, hk, au, in, id, ph, my, sg, tr, nl, be, at, dk, no, fi, ie, pl, pt, se, ch, ru, vn, th, il. Default is "us".

#### What sorting options can I use?

You can use "recommend", "MostPopular", "NewArrivals", "TopRated", "PriceLowtoHigh", or "PriceHightoLow". The scraper maps these to Shein’s API for consistent ordering.

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

Up to 1000 per search via the maxItems parameter. The default is 300.

#### How do I control pagination and page size?

Use page to set the starting page (default 1) and perPage to choose the page size as a string ("20"–"120"). The actor will iterate pages until maxItems is reached or no more products are available.

#### What if my requests get blocked?

The actor starts without a proxy for speed and cost efficiency. If blocked, it automatically retries with a datacenter proxy and then escalates to a residential proxy (3 retries). Once residential succeeds, it continues with it.

#### What data fields will I get in the output?

Each dataset row includes the search context (query, country, sort\_order) plus the full product object from Shein’s API, such as goods\_id, goods\_name, goods\_img, retailPrice, salePrice, and other metadata when available.

#### Can I use this in Python or via an API?

Yes. Run the actor and download results via the Apify API in your workflows (e.g., as a Shein product scraper Python integration) or export datasets as CSV/JSON/Excel for downstream use.

### Final thoughts

Shein Search Products Scraper is built for structured, scalable product data extraction from Shein search results. With dynamic header handling, robust proxy fallback, and live dataset streaming, it’s ideal for marketers, developers, analysts, and researchers who need consistent Shein catalog data. Integrate via the Apify API or your Python workflows to automate collection and export results to CSV/JSON for your BI stack. Start extracting smarter product insights across 38 countries 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("scrapier/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("scrapier/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 scrapier/shein-search-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shein Search Products Scraper",
        "description": "🛍️ Search & scrape Shein product data from 38 countries. 🔍 Keywords, filters, price range & sort options. 📦 Output: titles, prices, images, ratings & more.",
        "version": "0.1",
        "x-build-id": "L4PR9LVEwv4DapOcw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapier~shein-search-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapier-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/scrapier~shein-search-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapier-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/scrapier~shein-search-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapier-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
