# AliExpress Scraper | Product Listings and Prices (`parseforge/aliexpress-scraper`) Actor

Scrape AliExpress product listings including titles, prices, ratings, reviews, sold counts, shipping details, and seller information. Extract product images, variations, and store data from the global marketplace for price monitoring and product research

- **URL**: https://apify.com/parseforge/aliexpress-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛒 AliExpress Scraper

> 🚀 **Export AliExpress product listings in seconds.** Search any keyword and pull product titles, sale prices, original prices, currency, ratings, order counts, product images, and direct product URLs - no API key, no AliExpress account required.

> 🕒 **Last updated:** 2026-05-22 · **📊 10 fields** per record · **🌍 Global marketplace** · **📦 Millions of products** · **💵 Real-time pricing with discount data**

The **AliExpress Scraper** extracts live product listings directly from AliExpress search results. Each record includes 10 fields: product image, title, current sale price, original price (when discounted), currency, rating, order count, direct product URL, product ID, and scrape timestamp. The data is scraped in real-time using Camoufox (Firefox-based fingerprinting) with US residential proxies to bypass AliExpress's `_acw_runner` JavaScript challenge.

AliExpress hosts **hundreds of millions of product listings** across electronics, fashion, home goods, toys, and more - sourced from suppliers worldwide. Whether you need pricing data for 10 products or a full category sweep across thousands of listings, this Actor handles pagination automatically and delivers clean, structured records to your Apify dataset.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| E-commerce sellers, dropshippers, price intelligence teams, product researchers, import/export analysts, competitive intelligence teams | Dropshipping product research, price benchmarking, supplier discovery, trend monitoring, catalog enrichment |

---

### 📋 What the AliExpress Scraper does

Four core workflows in a single run:

- 🔍 **Keyword product search.** Enter any search term - "wireless earbuds", "phone case", "LED strip lights" - and get a ranked list of matching products.
- 💵 **Discount pricing.** Both `price` (current sale price) and `originalPrice` (pre-discount price) are extracted when a discount is active, so you can calculate exact discount percentages.
- 📦 **Demand signals.** `ordersCount` tells you how many units have been sold, which is the primary demand proxy used by dropshippers and product researchers.
- 🔗 **Clean product URLs.** Tracking parameters are stripped and URLs are normalized to canonical `aliexpress.com` format.

> 💡 **Why it matters:** AliExpress is the world's largest B2C dropshipping marketplace. Monitoring pricing, demand signals, and competitor stock without a scraper means manual searching and copy-paste - which doesn't scale. This Actor delivers structured product data in minutes, ready for your spreadsheet, database, or analysis pipeline.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded product dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>keyword</code></td><td>string</td><td><code>"laptop"</code></td><td>Keyword to search for on AliExpress (e.g. "wireless earbuds", "phone case").</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Products to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: 100 wireless earbuds listings.**

```json
{
    "keyword": "wireless earbuds",
    "maxItems": 100
}
````

**Example: 500 LED strip lights for price benchmarking.**

```json
{
    "keyword": "LED strip lights",
    "maxItems": 500
}
```

> ⚠️ **Good to Know:** AliExpress search returns approximately 60 products per page. The Actor paginates automatically until your `maxItems` limit is reached or no more results are available. Prices are returned in the currency embedded in the product link (typically USD for US residential proxy IPs). The `originalPrice` field will be null if no discount is active on a given listing.

***

### 📊 Output

Each product record contains **10 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | `"https://ae01.alicdn.com/kf/..."` |
| 🏷️ `title` | string | null | `"TWS Bluetooth 5.3 Wireless Earbuds"` |
| 💵 `price` | number | null | `12.99` |
| 🔖 `originalPrice` | number | null | `24.99` |
| 💱 `currency` | string | null | `"USD"` |
| ⭐ `rating` | number | null | `4.7` |
| 📦 `ordersCount` | number | null | `15823` |
| 🔗 `productUrl` | string | null | `"https://www.aliexpress.com/item/1005006..."` |
| 🆔 `productId` | string | null | `"1005006789012345"` |
| 🕒 `scrapedAt` | string | `"2026-05-22T14:30:00.000Z"` |

#### 📋 Sample Record

```json
{
    "imageUrl": "https://ae01.alicdn.com/kf/S1234567890abcdef.jpg",
    "title": "TWS Bluetooth 5.3 Wireless Earbuds Noise Cancelling",
    "price": 12.99,
    "originalPrice": 24.99,
    "currency": "USD",
    "rating": 4.7,
    "ordersCount": 15823,
    "productUrl": "https://www.aliexpress.com/item/1005006789012345.html",
    "productId": "1005006789012345",
    "scrapedAt": "2026-05-22T14:30:00.000Z"
}
```

***

### ✨ Why choose this Actor

- 🦊 **JS challenge bypass.** Camoufox (Firefox fingerprinting) with US residential proxies defeats AliExpress's `_acw_runner` bot detection layer.
- 💵 **Dual pricing.** Both sale price and original price are extracted from the `pdp_npi` URL parameter - the most reliable source on AliExpress for discount data.
- 📦 **Order count as demand proxy.** `ordersCount` is the standard dropshipper signal for product viability - returned as a clean integer.
- 🔗 **Canonical URLs.** Product URLs are normalized to `aliexpress.com` format with tracking parameters stripped, suitable for direct linking.
- 📄 **Multi-format export.** CSV, Excel, JSON, and XML available directly from the Apify dataset panel.
- ⚡ **Automatic pagination.** Pages through results automatically until `maxItems` is reached or AliExpress runs out of listings.

***

### 📈 How it compares to alternatives

| Feature | This Actor | AliExpress API (partner) | Manual search |
|---|---|---|---|
| No partner account needed | Yes | No | Yes |
| Discount / original price | Yes | Partial | Yes |
| Order count | Yes | Partial | Yes |
| Bulk export (500+ items) | Yes | Rate-limited | Impractical |
| CSV / Excel / JSON | Yes | JSON only | Manual |
| JS challenge bypass | Yes | N/A | N/A |

***

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (includes $5 free credit).
2. Open the **AliExpress Scraper** in the Apify Store.
3. Enter your search keyword (e.g. `"bluetooth speaker"`).
4. Set `maxItems` to control how many products you want.
5. Click **Save & Run**.
6. When the run finishes, open the **Dataset** tab and download as CSV, Excel, JSON, or XML.

***

### 💼 Business use cases

#### 🛒 Dropshipping product research

Find winning products by sorting scraped listings by `ordersCount` descending. A product with 10,000+ orders at a low price point is a proven demand signal. Compare `price` vs `originalPrice` to estimate supplier margins before adding to your store.

#### 💵 Price intelligence and benchmarking

Track competitor pricing for a product category on a weekly schedule. Feed price snapshots into a time-series database to detect price drops, seasonal discounting patterns, or supplier consolidation.

#### 📦 Catalog enrichment

Enrich your e-commerce product catalog with supplier pricing data. Use `productId` as a unique key to join AliExpress data with your internal SKU database.

#### 📈 Trend detection

Monitor rising `ordersCount` for a keyword category over multiple runs. Products showing rapid order growth week-over-week are early trend signals - useful for sourcing decisions or content strategy.

***

### 🔌 Automating AliExpress Scraper

Connect this Actor to your favorite automation platform in a few clicks:

- **Make (Integromat):** trigger on a schedule, push product data to Google Sheets or Airtable automatically.
- **Zapier:** connect new dataset items to Slack alerts, email digests, or Shopify product creation.
- **Apify Schedules:** set a daily or weekly cron inside the Apify console for recurring price monitoring.
- **Apify API:** call `POST /v2/acts/parseforge~aliexpress-scraper/runs` from any backend or data pipeline.
- **Webhooks:** fire a webhook to your server the moment a run completes and the dataset is ready.

***

### 🌟 Beyond business use cases

#### 🎓 Supply chain research

Economists and logistics researchers can use AliExpress pricing data to study manufacturer pricing behavior, platform fee structures, or the geography of global supply chains at scale.

#### 🔬 Algorithmic pricing experiments

Data scientists can use multi-run snapshots to build predictive models for AliExpress price fluctuations, testing hypotheses about order count thresholds, rating effects, or seasonal discount cycles.

#### 🛠️ Developer experiments

Build personal product recommendation engines, budget shopping assistants, or price comparison tools using structured AliExpress data without dealing with bot detection infrastructure.

#### 📊 Consumer protection analysis

Researchers studying counterfeit goods, misleading discount claims (inflated original prices), or consumer risk can use this data to analyze patterns across large product samples.

***

### 🤖 Ask an AI assistant about this scraper

Have questions? Paste this into any AI assistant:

> "I have a dataset of AliExpress products with fields: imageUrl, title, price, originalPrice, currency, rating, ordersCount, productUrl, productId, scrapedAt. Help me \[find the best value products / calculate discount percentages / identify top-selling items]."

***

### ❓ Frequently Asked Questions

**Q: What currency are prices returned in?**
A: Prices are extracted from the `pdp_npi` URL parameter embedded in product links, which typically reflects USD when using a US residential proxy IP. The `currency` field is populated from the same source.

**Q: Why is `originalPrice` null on some records?**
A: `originalPrice` is only populated when AliExpress is actively showing a crossed-out "was" price alongside the sale price. If no discount is displayed, only `price` is set.

**Q: How many products can I scrape?**
A: Free users are capped at 10 products per run. Paid users can scrape up to 1,000,000 products per run. AliExpress returns approximately 60 products per search page.

**Q: Can I scrape a specific product page?**
A: This Actor searches by keyword. For individual product pages, use the `productUrl` from a search run as a starting point for a follow-up detail-page scraper.

**Q: How is `ordersCount` extracted?**
A: Order count is parsed from the product card's text on the search results page (e.g. "15,823 sold"). It is returned as an integer.

**Q: Does this work for all AliExpress categories?**
A: Yes. Any keyword that returns results on AliExpress's main search will work. Category-specific landing pages are not supported - use keyword search instead.

**Q: What proxy type does this Actor use?**
A: US residential proxies via Apify's proxy infrastructure to bypass AliExpress's JavaScript challenge. Proxy costs are included in the Apify platform fee.

**Q: How do I schedule recurring price monitoring?**
A: Open the Actor in the Apify console, click **Schedule**, and set your preferred cron expression. Each run produces a fresh dataset snapshot.

**Q: Is the data real-time?**
A: Yes. All data is scraped live on every run - no cached or pre-fetched data.

**Q: Is this legal to use?**
A: This Actor scrapes publicly available search result pages. It does not bypass authentication or access private seller data. Review AliExpress's terms of service and your jurisdiction's applicable laws before using this data commercially.

**Q: What output formats are available?**
A: CSV, Excel (XLSX), JSON, and XML - all available directly from the Apify dataset panel with one click.

**Q: How do I get product images?**
A: Each record includes an `imageUrl` field pointing to AliExpress's CDN image for that product listing. The image can be used directly in web applications or downloaded programmatically.

***

### 🔌 Integrate with any app

| Platform | How |
|---|---|
| **Google Sheets** | Use Apify's Google Sheets integration or export CSV and import directly |
| **Airtable** | Connect via Make or Zapier, or import the CSV |
| **Shopify** | Use Zapier to push new products to your Shopify product catalog |
| **BigQuery** | Export JSON from the dataset and load via `bq load` |
| **Slack** | Use Apify Webhooks + Zapier to post price alerts to a channel |
| **Excel** | Download XLSX directly from the dataset panel |
| **Power BI** | Load the JSON or CSV dataset as a data source |
| **Notion** | Import CSV via Notion's built-in CSV importer |
| **Make** | Use the Apify module to watch for new datasets and route data |
| **REST API** | Poll `GET /v2/datasets/{datasetId}/items` for programmatic access |

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [Amazon Scraper](https://apify.com/parseforge/amazon-scraper) | Scrape Amazon US product search results |
| [eBay Scraper](https://apify.com/parseforge/ebay-scraper) | Extract product listings from eBay search |
| [Wayfair Scraper](https://apify.com/parseforge/wayfair-scraper) | Pull home goods listings from Wayfair |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering 200+ websites - all maintained, all export-ready.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or officially connected to AliExpress or Alibaba Group. All product names and trademarks are the property of their respective owners. Use this tool responsibly and in accordance with applicable terms of service.

# Actor input Schema

## `keyword` (type: `string`):

Keyword to search for on AliExpress (e.g. 'laptop', 'wireless earbuds', 'phone case')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "keyword": "laptop",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keyword": "laptop",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/aliexpress-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 = {
    "keyword": "laptop",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/aliexpress-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 '{
  "keyword": "laptop",
  "maxItems": 10
}' |
apify call parseforge/aliexpress-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AliExpress Scraper | Product Listings and Prices",
        "description": "Scrape AliExpress product listings including titles, prices, ratings, reviews, sold counts, shipping details, and seller information. Extract product images, variations, and store data from the global marketplace for price monitoring and product research",
        "version": "0.1",
        "x-build-id": "63plwntkJ1ij4DC1G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~aliexpress-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-aliexpress-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/parseforge~aliexpress-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-aliexpress-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/parseforge~aliexpress-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-aliexpress-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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Keyword to search for on AliExpress (e.g. 'laptop', 'wireless earbuds', 'phone case')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
