# AliExpress Product Scraper - Supplier Score & Profit Calculator (`sanztheo/my-actor`) Actor

Extract AliExpress products with supplier reliability scores (0-100) and automated profit calculator for dropshipping. Supports Amazon FBA, eBay, Shopify. Includes import tariffs 2025, ROI analysis, multi-region (FR, EN, ES, DE, IT). Playwright stealth anti-detection with session rotation.

- **URL**: https://apify.com/sanztheo/my-actor.md
- **Developed by:** [Theo Sanz](https://apify.com/sanztheo) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 218 total users, 18 monthly users, 100.0% runs succeeded, 10 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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.

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

## AliExpress Product Scraper API - Supplier Score & Profit Calculator

Extract AliExpress products with **supplier reliability scores (0-100)** and **automated profit analysis** for Amazon, eBay, Shopify dropshipping. The only scraper with ISM-based supplier quality ratings and ROI calculations.

### What Data Can You Extract from AliExpress?

| Data Field | Description | Example |
|------------|-------------|---------|
| **Product Info** | Title, ID, URL, images | "Wireless Bluetooth Earbuds TWS" |
| **Pricing** | Current price, original, discount % | $12.99 (was $25.98, -50%) |
| **Ratings** | Score, review count | 4.7/5 (3,245 reviews) |
| **Sales** | Units sold | 15,420 sold |
| **Shipping** | Free shipping, delivery time | Free, 15-25 days |
| **Supplier Score** | 0-100 reliability rating | 92/100 "Good" |
| **Supplier Details** | Name, years active, followers | "Official Store", 5 years, 125K |
| **Profit Analysis** | ROI, margin, platform fees | 36.6% margin, $9.15 profit |
| **Tariffs** | Import duties by country | US, UK, EU, CA, AU rates |

---

### AliExpress Scraper Unique Features

#### Supplier Reliability Scoring (Industry-First)

Automatically evaluates supplier quality using **ISM supply chain standards**:

- **0-100 reliability score** based on 5 weighted factors
- **Trust levels**: Excellent (95+), Good (85+), Acceptable (75+), Fair (65+), Poor (<65)
- **Score components**: Quality (35%), Delivery (30%), Communication (15%), Maturity (12%), Certifications (8%)
- Filter out risky suppliers before placing orders

#### Automated Dropshipping Profit Calculator

Get instant ROI analysis for every product:

- **Platform fees**: Amazon FBA (15%), eBay (13.25%), Shopify (2.9% + $0.30), Etsy (6.5%), Walmart (15%)
- **Import tariffs 2025**: Automatic duty calculation (US, UK, EU, CA, AU)
- **Profit margin & breakeven** calculations
- **Recommendation**: Excellent (30%+), Good (20%+), Acceptable (15%+), Low (<15%)

#### Multi-Region AliExpress Support

Scrape from 5 regional domains:

| Region | Domain | Currency |
|--------|--------|----------|
| French | fr.aliexpress.com | EUR |
| English | www.aliexpress.com | USD |
| Spanish | es.aliexpress.com | EUR |
| German | de.aliexpress.com | EUR |
| Italian | it.aliexpress.com | EUR |

#### Enterprise Anti-Detection System

- **Playwright cookie harvester** with stealth plugin
- **Dynamic fingerprint rotation** (user-agent, headers, screen resolution)
- **Session management** (10-min expiry, 50 requests/session)
- **Human-like delays** with Gaussian distribution
- **95%+ success rate** with residential proxies

---

### How Much Does AliExpress Scraper Cost?

**$0.0025 per product** ($2.50 per 1,000 products)

| Products | Cost | Use Case |
|----------|------|----------|
| 100 | $0.25 | Quick product research |
| 1,000 | $2.50 | Category analysis |
| 10,000 | $25.00 | Full market research |
| 50,000 | $125.00 | Enterprise sourcing |

**No monthly fees. No minimum. Pay only for results.**

---

### How to Use AliExpress Scraper

#### Required Input
- **keywords** (array) - 1-10 search terms

#### Optional Settings
| Parameter | Default | Description |
|-----------|---------|-------------|
| maxPages | 2 | Pages per keyword (~20 products/page) |
| maxConcurrency | 2 | Parallel requests (1-5) |
| language | fr | Regional domain (fr/en/es/de/it) |
| useProxy | true | Use Apify residential proxies |
| proxyCountryCode | FR | Proxy location (FR/US/GB/DE/ES/IT) |
| minDelay | 2000 | Minimum delay between requests (ms) |
| maxDelay | 6000 | Maximum delay between requests (ms) |

#### Example Input

```json
{
  "keywords": ["wireless earbuds", "phone holder", "usb cable"],
  "maxPages": 3,
  "language": "en",
  "maxConcurrency": 2,
  "useProxy": true,
  "proxyCountryCode": "US"
}
````

***

### AliExpress Product Data Output

Each product includes complete data with supplier scoring and profit analysis:

```json
{
  "id": "1005007890123456",
  "title": "Original Wireless Bluetooth Earphones TWS Earbuds",
  "url": "https://www.aliexpress.com/item/1005007890123456.html",
  "imageUrl": "https://ae01.alicdn.com/kf/S12345678.jpg",

  "price": {
    "current": 12.99,
    "original": 25.98,
    "currency": "USD",
    "discount": 50
  },

  "rating": {
    "score": 4.7,
    "count": 3245
  },

  "sales": {
    "count": 15420,
    "display": "15K+ sold"
  },

  "shipping": {
    "isFreeShipping": true,
    "price": 0,
    "estimatedDays": "15-25 days"
  },

  "supplier": {
    "id": "1234567",
    "name": "Official Store",
    "reliabilityScore": 92,
    "trustLevel": "Good",
    "feedbackScore": 4.8,
    "positiveRate": 98.5,
    "followerCount": 125000,
    "yearsActive": 5,
    "certifications": ["Top Brand", "Official Store"]
  },

  "profitAnalysis": {
    "costs": {
      "productCost": 12.99,
      "platformFees": 2.85,
      "tariff": 0,
      "totalCost": 15.84
    },
    "profit": {
      "grossProfit": 9.15,
      "profitMargin": 36.6,
      "roi": 57.8
    },
    "recommendation": "excellent"
  },

  "keyword": "wireless earbuds",
  "scrapedAt": "2026-01-22T10:30:00Z"
}
```

***

### AliExpress Scraper Use Cases

#### Dropshipping Product Research

- Find winning products with high sales and good ratings
- **Filter suppliers by reliability score** (avoid <75)
- Calculate profit margins before adding to store

#### Amazon FBA / eBay Arbitrage

- **Automated profit analysis** for your target platform
- Identify products with 30%+ profit margins
- Factor in import duties and VAT automatically

#### Market Research & Competitor Analysis

- Track pricing trends across categories
- Analyze top sellers and their suppliers
- Compare prices across 5 regional domains

#### Wholesale Supplier Verification

- **Verify supplier quality** with 0-100 reliability scores
- Check delivery performance and on-time rates
- Validate certifications (Top Brand, Official Store)

***

### How AliExpress Scraper Works

1. **Input keywords** - Provide 1-10 search terms
2. **Cookie harvesting** - Playwright auto-harvests session cookies with stealth
3. **Dual-mode scraping**:
   - **API mode** (with cookie) - Uses AliExpress internal API for accuracy
   - **HTML mode** (fallback) - Direct HTML parsing if API unavailable
4. **Anti-detection** - Rotates fingerprints, sessions, and proxies
5. **Supplier scoring** - Calculates 0-100 ISM-based reliability score
6. **Profit calculation** - Analyzes ROI with platform fees and tariffs
7. **Dataset export** - Download results as JSON, CSV, or Excel

#### Performance

| Metric | Value |
|--------|-------|
| Products per page | ~20 (AliExpress standard) |
| Recommended concurrency | 2-3 requests |
| Typical speed | 500-1,000 products/hour |
| Success rate | 95%+ with proxies |

***

### AliExpress Scraper vs Competitors

| Feature | This Scraper | Other Scrapers |
|---------|--------------|----------------|
| Supplier reliability score | **0-100 ISM-based** | Basic info only |
| Profit calculator | **7 platforms + 2025 tariffs** | Not included |
| Anti-detection | **Playwright + stealth + fingerprints** | Basic headers |
| Multi-region support | **5 domains** (FR, EN, ES, DE, IT) | 1-2 domains |
| Cookie harvesting | **Automatic Playwright** | Manual setup |
| Session rotation | **Auto (10min/50 requests)** | None |

***

### Frequently Asked Questions

#### Do I need an AliExpress account to scrape?

No. The scraper works without authentication. Cookies are harvested automatically.

#### How accurate is the supplier reliability score?

- **Search results only**: Estimated score with ~70% confidence
- **With store data**: Accurate score with ~95% confidence

#### Can I calculate profit for custom platforms?

Yes! Use `platform: "custom"` and provide your `customPlatformFee` percentage.

#### How do I avoid getting blocked by AliExpress?

- Enable **residential proxies** (`useProxy: true`)
- Lower **maxConcurrency** to 1-2
- Increase delays (`minDelay: 5000`, `maxDelay: 10000`)

#### What export formats are available?

JSON, CSV, Excel, and direct API access via Apify datasets.

#### Is this scraper compliant with AliExpress terms?

This tool is for research purposes. Users are responsible for compliance with AliExpress ToS.

***

### Support & Custom Development

- **Issues?** Open a ticket in the Issues tab
- **Custom features?** Contact for enterprise solutions
- **Updates**: Actor is actively maintained with regular updates

***

**Keywords**: aliexpress scraper, aliexpress api, aliexpress product data, dropshipping scraper, supplier quality score, profit calculator, amazon fba arbitrage, ebay dropshipping, shopify product research, aliexpress bulk extractor, supplier verification, import duty calculator, roi analysis tool, aliexpress crawler, product research api

# Actor input Schema

## `keywords` (type: `array`):

Products to search for on AliExpress. Each keyword can be a single word (e.g., 'phone') or a phrase (e.g., 'wireless bluetooth earbuds'). Results include product data, supplier scoring, and profit analysis.

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

Number of result pages per keyword. Each page contains ~20 products. Example: 2 pages = ~40 products per keyword.

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

Concurrent HTTP requests. Lower (1-2) = safer but slower. Higher (3-5) = faster but may trigger blocks. Recommended: 2.

## `language` (type: `string`):

Regional site to scrape. Affects product availability, prices, and currency.

## `useProxy` (type: `boolean`):

Use residential proxies to avoid IP blocking. HIGHLY RECOMMENDED for production.

## `proxyCountryCode` (type: `string`):

2-letter country code for proxies. Should match the AliExpress region for best results.

## `minDelay` (type: `integer`):

Minimum wait between requests. Lower = faster but riskier. Recommended: 2000ms.

## `maxDelay` (type: `integer`):

Maximum wait between requests. Recommended: 6000ms for safe scraping.

## Actor input object example

```json
{
  "keywords": [
    "wireless headphones",
    "phone case",
    "led strip lights"
  ],
  "maxPages": 2,
  "maxConcurrency": 2,
  "language": "fr",
  "useProxy": true,
  "proxyCountryCode": "FR",
  "minDelay": 2000,
  "maxDelay": 6000
}
```

# Actor output Schema

## `productDataset` (type: `string`):

All extracted products with pricing, ratings, sales data, supplier scores (0-100), and profit analysis

## `runSummary` (type: `string`):

Extraction summary with per-keyword stats, performance metrics, quota usage, and billing info

# 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 = {
    "keywords": [
        "smartphone case"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sanztheo/my-actor").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 = { "keywords": ["smartphone case"] }

# Run the Actor and wait for it to finish
run = client.actor("sanztheo/my-actor").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 '{
  "keywords": [
    "smartphone case"
  ]
}' |
apify call sanztheo/my-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AliExpress Product Scraper - Supplier Score & Profit Calculator",
        "description": "Extract AliExpress products with supplier reliability scores (0-100) and automated profit calculator for dropshipping. Supports Amazon FBA, eBay, Shopify. Includes import tariffs 2025, ROI analysis, multi-region (FR, EN, ES, DE, IT). Playwright stealth anti-detection with session rotation.",
        "version": "0.0",
        "x-build-id": "nQ7yKhXfFNHRggSA1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sanztheo~my-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sanztheo-my-actor",
                "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/sanztheo~my-actor/runs": {
            "post": {
                "operationId": "runs-sync-sanztheo-my-actor",
                "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/sanztheo~my-actor/run-sync": {
            "post": {
                "operationId": "run-sync-sanztheo-my-actor",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "minItems": 1,
                        "maxItems": 10,
                        "type": "array",
                        "description": "Products to search for on AliExpress. Each keyword can be a single word (e.g., 'phone') or a phrase (e.g., 'wireless bluetooth earbuds'). Results include product data, supplier scoring, and profit analysis.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPages": {
                        "title": "Pages per Keyword",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of result pages per keyword. Each page contains ~20 products. Example: 2 pages = ~40 products per keyword.",
                        "default": 2
                    },
                    "maxConcurrency": {
                        "title": "Parallel Requests",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Concurrent HTTP requests. Lower (1-2) = safer but slower. Higher (3-5) = faster but may trigger blocks. Recommended: 2.",
                        "default": 2
                    },
                    "language": {
                        "title": "AliExpress Region",
                        "enum": [
                            "fr",
                            "en",
                            "es",
                            "de",
                            "it"
                        ],
                        "type": "string",
                        "description": "Regional site to scrape. Affects product availability, prices, and currency.",
                        "default": "fr"
                    },
                    "useProxy": {
                        "title": "Enable Apify Proxy",
                        "type": "boolean",
                        "description": "Use residential proxies to avoid IP blocking. HIGHLY RECOMMENDED for production.",
                        "default": true
                    },
                    "proxyCountryCode": {
                        "title": "Proxy Country",
                        "enum": [
                            "FR",
                            "US",
                            "GB",
                            "DE",
                            "ES",
                            "IT",
                            "CA",
                            "AU"
                        ],
                        "type": "string",
                        "description": "2-letter country code for proxies. Should match the AliExpress region for best results.",
                        "default": "FR"
                    },
                    "minDelay": {
                        "title": "Min Delay (ms)",
                        "minimum": 1000,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Minimum wait between requests. Lower = faster but riskier. Recommended: 2000ms.",
                        "default": 2000
                    },
                    "maxDelay": {
                        "title": "Max Delay (ms)",
                        "minimum": 2000,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum wait between requests. Recommended: 6000ms for safe scraping.",
                        "default": 6000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
