# Temu Scraper — Product Prices, Reviews & Deals (`junipr/temu-scraper`) Actor

Scrape Temu product listings and search results. Extract prices, reviews, ratings, shipping info, and product specs. Monitor deals, track prices, and analyze product trends.

- **URL**: https://apify.com/junipr/temu-scraper.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $61.70 / 1,000 product scrapeds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Temu Product Scraper

### What is Temu Product Scraper?

Temu Product Scraper is the first dedicated Temu scraping tool on the Apify Store. It extracts structured product data from Temu.com at scale — search by keywords, scrape direct product URLs, or browse entire category pages. For each product, the actor collects over 20 data points including title, current and original prices, discount percentage, stock status, star rating, review count, sales volume, seller details, size/color variants with individual pricing, product images, shipping information, specifications, and customer reviews with photos.

The scraper handles Temu's aggressive anti-bot protections using Playwright with full browser rendering, rotating residential proxies, randomized fingerprints (viewport, user agent, WebGL), session rotation, and jittered delays between requests. It is designed for dropshipping research, price comparison services, market analysis, and competitive intelligence — at a fraction of the cost of enterprise scraping solutions.

### What can it do?

- **Search by keyword** — enter any search term and extract up to 10,000 matching products with pricing, ratings, and images
- **Scrape product pages** — provide direct Temu product URLs for full extraction including reviews, variants, seller info, and specifications
- **Browse categories** — scrape entire category listing pages to discover products
- **Extract reviews** — pull customer reviews with author, rating, date, text, images, and verified purchase status
- **Variant extraction** — get all size, color, and style options with individual pricing and stock status
- **Seller details** — shop name, rating, follower count, product count, and store URL
- **Multi-country support** — set target country and language for localized pricing and product content
- **Sort and filter** — sort by relevance, price, best selling, or newest; filter by price range
- **Pay-per-result** — only charged for successfully scraped products ($61.70 per 1,000)

### What data can you extract?

| Field | Description |
|-------|-------------|
| `url` | Product page URL |
| `productId` | Temu product identifier |
| `title` | Product title |
| `description` | Full product description (up to 10,000 chars) |
| `price` | Current sale price |
| `originalPrice` | Price before discount |
| `currency` | Currency code (USD, EUR, GBP, etc.) |
| `discount` | Discount percentage |
| `inStock` | Whether the product is available |
| `salesCount` | Number of units sold (e.g. "10K+ sold") |
| `rating` | Average star rating (0-5) |
| `reviewCount` | Total number of reviews |
| `category` | Full category path |
| `images` | Array of all product image URLs |
| `variants` | Size/color/style options with prices |
| `seller` | Shop name, rating, followers, product count |
| `reviews` | Customer reviews with text, rating, images |
| `specifications` | Product specs (brand, material, etc.) |
| `shipping` | Free shipping, delivery estimate, return policy |
| `tags` | Product tags and keywords |

### How to use Temu Scraper

1. **Create a new task** from this actor on the Apify platform
2. **Enter your input** — at minimum, add a search term (e.g. "wireless earbuds") or paste Temu product URLs
3. **Configure options** — set max products, enable/disable reviews, choose country and language
4. **Run the actor** — click Start and wait for results. Keep the first run small, then increase limits after confirming proxy reliability.
5. **Download results** — export as JSON, CSV, Excel, or use the Apify API to fetch results programmatically

**Minimal input (zero-config):**
```json
{
  "searchTerms": ["phone case"]
}
````

**Full input example:**

```json
{
  "searchTerms": ["wireless earbuds", "phone case"],
  "maxProducts": 1,
  "includeReviews": false,
  "maxReviews": 0,
  "includeVariants": false,
  "country": "US",
  "sortBy": "best_selling",
  "minPrice": 5,
  "maxPrice": 50
}
```

### Pricing and cost estimation

This actor uses pay-per-result pricing at **$61.70 per 1,000 products** scraped.

Pricing includes all platform compute costs — no hidden fees.

| Volume | Cost |
|--------|------|
| 100 products | $6.17 |
| 1,000 products | $61.70 |
| 10,000 products/month | $617.00 |
| 100,000 products/month | $6,170.00 |

Compare to alternatives: Bright Data Temu collector ($500+/month), Oxylabs enterprise ($1,000+/month), or building a custom scraper (weeks of engineering time). Temu Product Scraper gives you structured data at a fraction of the cost with zero setup.

### Output example

```json
{
  "url": "https://www.temu.com/wireless-bluetooth-earbuds-abc123.html",
  "productId": "601099520849181",
  "title": "Wireless Bluetooth Earbuds with Charging Case",
  "description": "High quality wireless earbuds with noise cancellation...",
  "price": 8.99,
  "originalPrice": 24.99,
  "currency": "USD",
  "discount": "64%",
  "inStock": true,
  "salesCount": "10K+ sold",
  "rating": 4.7,
  "reviewCount": 2341,
  "category": "Electronics > Audio > Earbuds",
  "categoryBreadcrumb": ["Electronics", "Audio", "Earbuds"],
  "images": ["https://img.kwcdn.com/product/..."],
  "thumbnailUrl": "https://img.kwcdn.com/product/...",
  "variants": [
    {
      "name": "Color",
      "options": [
        {"value": "Black", "price": 8.99, "inStock": true, "image": "https://..."},
        {"value": "White", "price": 8.99, "inStock": true, "image": "https://..."}
      ]
    }
  ],
  "seller": {
    "name": "TechStore Official",
    "id": "seller_12345",
    "rating": 4.8,
    "followers": "5.2K",
    "productCount": 342,
    "url": "https://www.temu.com/store/..."
  },
  "reviews": [
    {
      "author": "John D.",
      "rating": 5,
      "date": "2026-02-15",
      "text": "Great sound quality for the price...",
      "images": [],
      "helpful": 12,
      "verified": true
    }
  ],
  "specifications": {
    "Brand": "Generic",
    "Connectivity": "Bluetooth 5.3",
    "Battery Life": "6 hours"
  },
  "shipping": {
    "freeShipping": true,
    "estimatedDelivery": "Feb 28 - Mar 5",
    "returnPolicy": "90 days free return"
  },
  "tags": ["wireless", "bluetooth", "earbuds"],
  "hasVideo": false,
  "scrapedAt": "2026-03-11T12:00:00.000Z"
}
```

### Related scrapers by Junipr

- [Etsy Product Scraper](https://apify.com/junipr/etsy-product-scraper) — scrape Etsy product listings, prices, ratings, and shop data
- [Google News Scraper](https://apify.com/junipr/google-news-scraper) — scrape news articles from Google News by keyword or topic
- [Contact Info Scraper](https://apify.com/junipr/contact-info-scraper) — extract contact information from websites
- [SEO Audit Tool](https://apify.com/junipr/seo-audit-tool) — run a full technical SEO audit on any website
- [JSON to CSV Converter](https://apify.com/junipr/json-to-csv-converter) — convert scraped data to CSV or Excel format

### FAQ

#### How much does it cost to scrape Temu?

Temu Product Scraper charges $61.70 per 1,000 products successfully scraped. Failed extractions (404s, blocked requests, empty results) are never charged. For example, scraping 10,000 products per month costs approximately $617 — still below many enterprise scraping contracts.

#### Can I scrape Temu product reviews?

Yes. Set `includeReviews` to `true` and configure `maxReviews` to control how many reviews per product (up to 100). Each review includes the author name, star rating, date, review text, attached images, helpful vote count, and verified purchase status.

#### What countries does Temu Scraper support?

The scraper supports any country where Temu operates. Set the `country` parameter to an ISO 3166-1 alpha-2 code (e.g., `US`, `DE`, `GB`, `FR`, `AU`, `CA`) and the `language` parameter to your preferred language code (e.g., `en`, `de`, `fr`). Prices and availability reflect the target country.

#### How do I export Temu data to CSV or Excel?

After the actor finishes, go to the Dataset tab in the Apify Console. Click the Export button and choose CSV, Excel, JSON, or XML format. You can also use the Apify API to fetch results programmatically: `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=csv`.

#### Is scraping Temu legal?

Web scraping of publicly available data exists in a legal gray area. This actor only extracts publicly visible product information — no login is required, and no private or personal data is collected beyond reviewer display names (which are pseudonymized). Users are responsible for ensuring their use of scraped data complies with applicable laws and Temu's Terms of Service. We recommend reviewing your jurisdiction's data protection regulations before large-scale scraping.

#### How often can I run the scraper?

You can run the scraper as often as needed. For price monitoring, we recommend scheduling runs every 6-12 hours using Apify's built-in scheduler. For market research or one-time data collection, run on demand. The actor handles rate limiting and session rotation automatically to maintain reliability across repeated runs.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search for products on Temu (e.g. "wireless earbuds", "phone case"). Enter one term per line.

## `productUrls` (type: `array`):

Direct Temu product page URLs to scrape. Each URL must be a valid temu.com product link.

## `categoryUrls` (type: `array`):

Temu category or listing page URLs to browse and extract products from.

## `maxProducts` (type: `integer`):

Maximum number of products to extract per search term or category.

## `includeReviews` (type: `boolean`):

Extract product reviews (author, rating, text, images).

## `maxReviews` (type: `integer`):

Maximum number of reviews to extract per product.

## `includeImages` (type: `boolean`):

Extract all product image URLs.

## `includeSeller` (type: `boolean`):

Extract seller/shop details (name, rating, follower count).

## `includeVariants` (type: `boolean`):

Extract product variants (sizes, colors, styles) with individual prices.

## `country` (type: `string`):

Target country for pricing and availability (ISO 3166-1 alpha-2 code, e.g. US, DE, GB, FR).

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

Language for product content (ISO 639-1 code, e.g. en, de, fr, es).

## `sortBy` (type: `string`):

Sort order for search results.

## `minPrice` (type: `number`):

Minimum price filter in target currency. Leave empty for no minimum.

## `maxPrice` (type: `number`):

Maximum price filter in target currency. Leave 0 for no maximum.

## `proxyConfig` (type: `object`):

Residential proxy is required — Temu aggressively blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.

## Actor input object example

```json
{
  "searchTerms": [
    "wireless earbuds"
  ],
  "productUrls": [],
  "categoryUrls": [],
  "maxProducts": 1,
  "includeReviews": false,
  "maxReviews": 0,
  "includeImages": false,
  "includeSeller": false,
  "includeVariants": false,
  "country": "US",
  "language": "en",
  "sortBy": "relevance",
  "minPrice": 0,
  "maxPrice": 0,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Scraped Temu product data with full details — prices, reviews, seller info, variants, images, and specifications.

# 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 = {
    "searchTerms": [
        "wireless earbuds"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/temu-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 = { "searchTerms": ["wireless earbuds"] }

# Run the Actor and wait for it to finish
run = client.actor("junipr/temu-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 '{
  "searchTerms": [
    "wireless earbuds"
  ]
}' |
apify call junipr/temu-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Temu Scraper — Product Prices, Reviews & Deals",
        "description": "Scrape Temu product listings and search results. Extract prices, reviews, ratings, shipping info, and product specs. Monitor deals, track prices, and analyze product trends.",
        "version": "1.0",
        "x-build-id": "eoIHigYuWvZIQjN1f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~temu-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-temu-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/junipr~temu-scraper/runs": {
            "post": {
                "operationId": "runs-sync-junipr-temu-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/junipr~temu-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-temu-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search for products on Temu (e.g. \"wireless earbuds\", \"phone case\"). Enter one term per line.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "wireless earbuds"
                        ]
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct Temu product page URLs to scrape. Each URL must be a valid temu.com product link.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "categoryUrls": {
                        "title": "Category URLs",
                        "type": "array",
                        "description": "Temu category or listing page URLs to browse and extract products from.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxProducts": {
                        "title": "Max Products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to extract per search term or category.",
                        "default": 1
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Extract product reviews (author, rating, text, images).",
                        "default": false
                    },
                    "maxReviews": {
                        "title": "Max Reviews per Product",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per product.",
                        "default": 0
                    },
                    "includeImages": {
                        "title": "Include Images",
                        "type": "boolean",
                        "description": "Extract all product image URLs.",
                        "default": false
                    },
                    "includeSeller": {
                        "title": "Include Seller Info",
                        "type": "boolean",
                        "description": "Extract seller/shop details (name, rating, follower count).",
                        "default": false
                    },
                    "includeVariants": {
                        "title": "Include Variants",
                        "type": "boolean",
                        "description": "Extract product variants (sizes, colors, styles) with individual prices.",
                        "default": false
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Target country for pricing and availability (ISO 3166-1 alpha-2 code, e.g. US, DE, GB, FR).",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language for product content (ISO 639-1 code, e.g. en, de, fr, es).",
                        "default": "en"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "price_low",
                            "price_high",
                            "best_selling",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "maximum": 999999,
                        "type": "number",
                        "description": "Minimum price filter in target currency. Leave empty for no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "maximum": 999999,
                        "type": "number",
                        "description": "Maximum price filter in target currency. Leave 0 for no maximum.",
                        "default": 0
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is required — Temu aggressively blocks datacenter IPs. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
