# SHEIN Scraper (All Page Types) (`hypebridge/shein-scraper`) Actor

Extracts product listings and product detail data from [SHEIN US](https://us.shein.com/). You can use it to collect products from the homepage, search result pages, supported SHEIN category pages, and direct product pages, then export the results as JSON, CSV, Excel, or HTML from the Dataset tab.

- **URL**: https://apify.com/hypebridge/shein-scraper.md
- **Developed by:** [Hypebridge](https://apify.com/hypebridge) (community)
- **Categories:** E-commerce, Automation, Agents
- **Stats:** 33 total users, 7 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $120.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

### What does SHEIN Product Listing Scraper do?

**SHEIN Product Listing Scraper** extracts listing-level product data from [SHEIN](https://us.shein.com/). Use it to collect products from the homepage, search result pages, supported category pages, other product-listing pages, and direct product page URLs from SHEIN country subdomains.

The actor focuses on fields proven reliable across live runs: product name, price, URL, images, category, ranking position, and source metadata.

### Why scrape SHEIN?

- **Track products and pricing**: Monitor current prices, discounts, and product availability across search or category pages.
- **Build product datasets**: Export structured fashion catalog data for analysis, research, or internal merchandising workflows.
- **Compare categories and search demand**: See what products appear for a keyword or within a supported SHEIN category page.
- **Normalize country-subdomain inputs**: Accept SHEIN country URLs while extracting through the working catalog session.

### What data can SHEIN Product Listing Scraper extract?

| Field | Type | Description |
| --- | --- | --- |
| `sourceUrl` | String | The page URL that produced the product |
| `sourceType` | String | Homepage, search, category selection, direct product, or generic listing source |
| `goodsId` | String | SHEIN product identifier |
| `title` | String | Product name |
| `productUrl` | String | Product page URL |
| `imageUrl` | String | Main product image |
| `imageUrls` | Array | Listing image URLs when available |
| `price` | Number | Current sale price |
| `priceText` | String | Raw price text when available |
| `listPrice` | Number | Original price when available |
| `discountPrice` | Number | Separately exposed discount value when available |
| `discountPercent` | Number | Discount percentage when available |
| `categoryId` | String | SHEIN category ID when available |
| `description` | String | Product-page description when PDP recovery reaches the detail payload |
| `productDetails` | Array | Product specification rows such as color, material, power supply, batteries, or displayed SKU |
| `attributes` | Object | Product specification rows keyed by attribute name |
| `materials` | Array | Material/composition details when separately exposed |
| `sku` | String | Displayed product SKU when available |
| `skus` | Array | Variant SKU records with attributes, stock, and price snippets when available |
| `colors` | Array | Color variants from the PDP sale attributes |
| `sizes` | Array | Size values inferred from variant attributes |
| `brand` | Object | Brand metadata when available |
| `store` | Object | Store card metadata such as name, logo, rating, item count, and follower count |
| `reviews` | Object | Review rating/count summary when available |
| `stock` | Number | Product-level stock when exposed |
| `categoryTree` | Array | Product category breadcrumb records when available |
| `shipping` | Object | Compact shipping snippets when exposed |
| `detailFieldCoverage` | Array | Detail-field groups populated by PDP browser recovery |
| `searchKeyword` | String | Search term used for search-result runs or direct product indirection |
| `selectId` | String | Category selection identifier for supported category pages |
| `rank` | Number | Product position within the current page response |
| `extractionStatus` | String | `partial` when a direct product URL could not be resolved through search indirection |
| `extractionErrorMessage` | String | Reason a direct product URL only produced a URL-level fallback record |

The full field list is available in the **Output** tab.

### Supported URLs

| Type | Example |
| --- | --- |
| Homepage | `https://us.shein.com/` |
| Search | `https://au.shein.com/pdsearch/shorts/?search_source=4&search_type=all&source=hotWord` |
| Category page | `https://de.shein.com/RecommendSelection/Men-Clothing-sc-017172963.html` |
| Recommend category page | `https://ca.shein.com/recommend/New-in-Blouses-sc-10050028999.html` |
| Standard category page | `https://us.shein.com/Women-Dresses-c-1727.html` |
| Direct product page | `https://ca.shein.com/SHEIN-EZwear-Ripped-Raw-Trim-Denim-Shorts-Y2k-p-11133529.html?mallCode=1` |

Known listing URL shapes use optimized routes. Direct product pages are resolved through the working search API when the product is discoverable there. Other SHEIN pages use a warmed browser fallback that extracts embedded or visible product cards when present. Product data and prices are extracted through the US catalog session, so `currency` is reported as `USD`.

### How to scrape SHEIN

1. Open **SHEIN Product Listing Scraper** on Apify.
2. Add one or more supported `startUrls`.
3. Set `maxItems` to control the size of the run.
4. Set `maxPagesPerStartUrl` if you want to limit pagination.
5. Start the run and download results from the **Dataset** tab.

### Input

See the **Input** tab for the full schema. The main fields are:

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `startUrls` | Array | `[]` | Homepage, search, category, product, or product-listing URLs from SHEIN country subdomains. Empty input exits successfully with no rows |
| `maxItems` | Number | `500` | Maximum number of products to output. Use `0` for unlimited |
| `maxPagesPerStartUrl` | Number | `10` | Maximum number of pages to process per input URL |
| `maxConcurrency` | Number | `2` | Number of browser pages processed in parallel |
| `debugMode` | Boolean | `false` | Saves extra run artifacts for troubleshooting |
| `enablePdpBrowserRecovery` | Boolean | `false` | PDP detail recovery for direct product URLs using source-country click-through, residential CA egress, and a coherent desktop browser identity. This input is honored only when the actor-level `SHEIN_PDP_BROWSER_RECOVERY_ENABLED` feature flag is enabled |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://au.shein.com/pdsearch/shorts/?search_source=4&search_type=all&source=hotWord" },
    { "url": "https://de.shein.com/RecommendSelection/Men-Clothing-sc-017172963.html" },
    { "url": "https://ca.shein.com/SHEIN-EZwear-Ripped-Raw-Trim-Denim-Shorts-Y2k-p-11133529.html?mallCode=1" }
  ],
  "maxItems": 100,
  "maxPagesPerStartUrl": 2
}
````

### Output

Results are stored in the **Dataset** tab and can be downloaded as JSON, CSV, Excel, or HTML.

Each item can include:

- **Listing data**: title, product URL, images, price, discount, category, ranking
- **Source metadata**: source URL, source type, search keyword, category selection ID
- **Detail data for recovered PDPs**: description, specification rows, displayed SKU, variants, store, brand, reviews, stock, category breadcrumbs, and compact shipping snippets when SHEIN exposes them
- **Detail recovery metadata**: extraction method, field coverage, partial status, and error message for direct product URLs

### Pricing

The default listing/search/category paths keep the existing cost profile. PDP detail recovery is a separate opt-in path because it uses browser navigation plus residential proxy traffic.

When pay-per-event pricing is configured, the actor emits this additional event:

| Event | When charged | Recommended price |
| --- | --- | --- |
| `pdp-detail-item` | One successfully recovered PDP detail row with `extractionMethod: "pdpBrowserRecovery"` | See current pricing proposal before enabling publicly |

The `enablePdpBrowserRecovery` input is guarded by the actor-level `SHEIN_PDP_BROWSER_RECOVERY_ENABLED` feature flag so pricing can be updated before users can access the higher-cost path.

#### Sample output

```json
{
  "sourceUrl": "https://us.shein.com/pdsearch/shorts?page=1",
  "sourceType": "search",
  "goodsId": "11133529",
  "title": "SHEIN EZwear Ripped Raw Trim Denim Shorts Y2k",
  "productUrl": "https://us.shein.com/SHEIN-EZwear-Ripped-Raw-Trim-Denim-Shorts-Y2k-p-11133529.html?mallCode=1",
  "imageUrl": "https://img.ltwebstatic.com/images3_pi/2023/02/01/example_thumbnail_405x552.jpg",
  "price": 23.24,
  "listPrice": 36.52,
  "discountPercent": 36,
  "categoryId": "1935",
  "searchKeyword": "shorts",
  "rank": 1
}
```

### Tips

- Use smaller `maxItems` values when testing new inputs.
- Prefer search and supported category URLs when you need consistent result volume.
- Direct product URLs return listing-level data only when the product is discoverable through the working search API.

### FAQ

#### Can this scrape product pages?

You can provide a direct product page as a start URL. The actor resolves it through SHEIN search and returns listing-level data when the matching `goodsId` appears in search results. If it cannot be resolved, the actor saves a partial URL-level row instead of failing the run.

#### Does it support every SHEIN URL?

It accepts SHEIN country-subdomain URLs and uses optimized handling for homepage, search, `RecommendSelection`, and product pages. Other SHEIN pages use a generic product-card fallback; pages without embedded or visible products may return no rows instead of failing the run.

#### Can I export the results?

Yes. Results are stored in the **Dataset** tab and can be downloaded as JSON, CSV, Excel, or HTML.

### Support

- Questions or feature requests: use the Actor page or your internal issue tracker
- Programmatic access: use the **API** tab in Apify

# Actor input Schema

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

SHEIN URLs to scrape — homepage, search results, category pages, product pages, store pages (/store/home?store\_code=…), or other product-listing pages from shein.com country subdomains.

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

Maximum number of products to extract across all sources. Set to 0 for unlimited.

## `maxPagesPerStartUrl` (type: `integer`):

Maximum number of paginated pages to crawl for each input URL. Each page returns up to 120 products.

## `maxConcurrency` (type: `integer`):

Browser pages processed in parallel. Keep low — SHEIN rate-limits warmed sessions aggressively.

## `debugMode` (type: `boolean`):

Save screenshots and HTML to the key-value store when a block or malformed response is encountered.

## `enablePdpBrowserRecovery` (type: `boolean`):

Opt-in PDP detail recovery for direct product URLs. This uses source-country search click-through, a coherent desktop browser identity, and Residential CA egress, so it is slower and more expensive than the default path. This input is honored only when the actor-level SHEIN\_PDP\_BROWSER\_RECOVERY\_ENABLED feature flag is enabled.

## `navigationDelayMs` (type: `integer`):

Milliseconds to wait after the SHEIN homepage warmup before calling session-native APIs. Keep this high enough for SHEIN's client SDKs to expose schttp.

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

Residential proxies are strongly recommended — datacenter IPs hit SHEIN's risk pages quickly.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://us.shein.com/pdsearch/quilted-v-pattern-small-square-crossbody-bag"
    }
  ],
  "maxItems": 10,
  "maxPagesPerStartUrl": 1,
  "maxConcurrency": 2,
  "debugMode": false,
  "enablePdpBrowserRecovery": false,
  "navigationDelayMs": 8000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `defaultView` (type: `string`):

Complete dataset with every extracted field.

## `overviewView` (type: `string`):

Overview dataset view with the most commonly used listing fields.

## `files` (type: `string`):

Debug screenshots, HTML, and payload metadata saved to the default key-value store when debug mode is enabled.

# 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 = {
    "startUrls": [
        {
            "url": "https://us.shein.com/pdsearch/quilted-v-pattern-small-square-crossbody-bag"
        }
    ],
    "maxItems": 10,
    "maxPagesPerStartUrl": 1,
    "maxConcurrency": 2,
    "debugMode": false,
    "enablePdpBrowserRecovery": false,
    "navigationDelayMs": 8000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("hypebridge/shein-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 = {
    "startUrls": [{ "url": "https://us.shein.com/pdsearch/quilted-v-pattern-small-square-crossbody-bag" }],
    "maxItems": 10,
    "maxPagesPerStartUrl": 1,
    "maxConcurrency": 2,
    "debugMode": False,
    "enablePdpBrowserRecovery": False,
    "navigationDelayMs": 8000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("hypebridge/shein-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 '{
  "startUrls": [
    {
      "url": "https://us.shein.com/pdsearch/quilted-v-pattern-small-square-crossbody-bag"
    }
  ],
  "maxItems": 10,
  "maxPagesPerStartUrl": 1,
  "maxConcurrency": 2,
  "debugMode": false,
  "enablePdpBrowserRecovery": false,
  "navigationDelayMs": 8000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call hypebridge/shein-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SHEIN Scraper (All Page Types)",
        "description": "Extracts product listings and product detail data from [SHEIN US](https://us.shein.com/). You can use it to collect products from the homepage, search result pages, supported SHEIN category pages, and direct product pages, then export the results as JSON, CSV, Excel, or HTML from the Dataset tab.",
        "version": "0.0",
        "x-build-id": "qtQMS7cM9cginVWVP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hypebridge~shein-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hypebridge-shein-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/hypebridge~shein-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hypebridge-shein-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/hypebridge~shein-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hypebridge-shein-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": {
                    "startUrls": {
                        "title": "URLs",
                        "type": "array",
                        "description": "SHEIN URLs to scrape — homepage, search results, category pages, product pages, store pages (/store/home?store_code=…), or other product-listing pages from shein.com country subdomains.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to extract across all sources. Set to 0 for unlimited.",
                        "default": 500
                    },
                    "maxPagesPerStartUrl": {
                        "title": "Max pages per URL",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of paginated pages to crawl for each input URL. Each page returns up to 120 products.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Browser pages processed in parallel. Keep low — SHEIN rate-limits warmed sessions aggressively.",
                        "default": 2
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Save screenshots and HTML to the key-value store when a block or malformed response is encountered.",
                        "default": false
                    },
                    "enablePdpBrowserRecovery": {
                        "title": "PDP detail recovery",
                        "type": "boolean",
                        "description": "Opt-in PDP detail recovery for direct product URLs. This uses source-country search click-through, a coherent desktop browser identity, and Residential CA egress, so it is slower and more expensive than the default path. This input is honored only when the actor-level SHEIN_PDP_BROWSER_RECOVERY_ENABLED feature flag is enabled.",
                        "default": false
                    },
                    "navigationDelayMs": {
                        "title": "Warmup delay",
                        "minimum": 1000,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Milliseconds to wait after the SHEIN homepage warmup before calling session-native APIs. Keep this high enough for SHEIN's client SDKs to expose schttp.",
                        "default": 8000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are strongly recommended — datacenter IPs hit SHEIN's risk pages quickly.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
