# Sephora Product Reviews Scraper (`stealth_mode/sephora-product-reviews-scraper`) Actor

Scrape comprehensive product reviews from Sephora.com including ratings, verified purchases, user feedback, and review metadata. Extract customer insights, sentiment data, and product performance metrics for beauty market research and competitive analysis.

- **URL**: https://apify.com/stealth\_mode/sephora-product-reviews-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Sephora Product Reviews Scraper: Extract Beauty Product Customer Feedback

### What This Scraper Does

The Sephora Product Reviews Scraper extracts customer reviews from individual product pages on Sephora.com. It captures complete review data including ratings, review text, user information, helpfulness votes, verification status, and temporal metadata—essential for understanding product performance and customer sentiment in the competitive beauty market.

Sephora hosts millions of authentic customer reviews across makeup, skincare, haircare, and fragrance products. This data reveals product strengths and weaknesses, ingredient concerns, shade matching issues, and usage patterns that drive purchasing decisions. For beauty brands, retailers, and market researchers, this review data provides unfiltered customer intelligence.

**Key Users:**
- **Beauty brands** monitoring product reception and competitor performance
- **Market researchers** analyzing beauty trends and consumer preferences
- **E-commerce platforms** building review aggregation systems
- **Product development teams** identifying improvement opportunities from customer feedback
- **Marketing agencies** extracting testimonials and understanding messaging effectiveness

### Input Configuration

The scraper processes individual Sephora product detail pages—the pages showing full product information and customer reviews.

**Example Configuration:**

```json
{
  "urls": [
    "https://www.sephora.com/product/diorshow-waterproof-mascara-P99901?skuId=838763"
  ],
  "sort_by": "SubmissionTime:desc",
  "offset": 0,
  "ignore_url_failures": true,
  "max_items_per_url": 50
}
````

**Parameters Explained:**

**urls:** Array of Sephora product detail URLs. Format: `https://www.sephora.com/product/[product-name]-[product-id]`. Collect these by browsing Sephora or using search/category scrapers.

**sort\_by:** Controls review ordering. Options:

- `""` (Any): Default Sephora sorting
- `"TotalPositiveFeedbackCount:desc"`: Most helpful reviews first
- `"Rating:desc"`: Highest ratings first
- `"Rating:asc"`: Lowest ratings first (critical for finding issues)
- `"SubmissionTime:desc"`: Newest reviews first (trending sentiment)
- `"SubmissionTime:asc"`: Oldest reviews first (historical analysis)

**offset:** Starting position for pagination. Use 0 to start from beginning, increment by `max_items_per_url` for subsequent pages (e.g., 0, 50, 100).

**ignore\_url\_failures:** Set `true` when scraping multiple products. Individual failures (discontinued products, removed pages) won't stop the entire run.

**max\_items\_per\_url:** Reviews to extract per product (1-100 recommended). Sephora products can have thousands of reviews—set higher values for comprehensive extraction or paginate through offset.

### Output Structure: Complete Review Data

**Sample Output:**

```json
{
  "id": "385595464",
  "cid": null,
  "source_client": "sephora",
  "badges": {
    "verified_purchaser": {
      "content_type": "REVIEW",
      "id": "verifiedPurchaser",
      "badge_type": "Custom"
    }
  },
  "badges_order": [
    "verifiedPurchaser"
  ],
  "last_moderated_time": "2026-04-27T20:31:19.000+00:00",
  "last_modification_time": "2026-04-27T20:31:19.000+00:00",
  "product_id": "838763",
  "original_product_name": "Diorshow Waterproof Mascara Catwalk Black",
  "campaign_id": "iOS App",
  "context_data_values_order": [
    "IncentivizedReview",
    "StaffContext",
    "skinTone",
    "skinType",
    "eyeColor",
    "ageRange",
    "skinConcerns"
  ],
  "author_id": "62575127160",
  "content_locale": "en_US",
  "is_featured": false,
  "total_inappropriate_feedback_count": 0,
  "total_client_response_count": 0,
  "total_comment_count": 0,
  "rating": 5,
  "is_ratings_only": false,
  "is_recommended": true,
  "total_feedback_count": 0,
  "total_negative_feedback_count": 0,
  "total_positive_feedback_count": 0,
  "moderation_status": "APPROVED",
  "submission_id": "r18723-en__17773206ovQY785LCU",
  "submission_time": "2026-04-27T20:10:23.000+00:00",
  "review_text": "The first try wasn’t good, since I went under my eyes. But after giving it second chance I absolutely loved it. Lasts all day keep eyelashes curled very well! Recommend.",
  "title": "Definitely worth a try",
  "user_nickname": "Toma9",
  "additional_fields": {
    "sociallockup": {
      "value": "avatar=https://community.sephora.com/t5/image/serverpage/avatar-name/default-avatar/avatar-theme/sephora/avatar-collection/sephora/avatar-display-size/profile/version/2?xdesc=1.0|biBadgeUrl=/html/rank_icons/birole_insider.png|engagementBadgeUrl=/html/rank_icons/window_shopper_1.png|biTier=vib",
      "id": "sociallockup",
      "label": "sociallockup"
    }
  },
  "additional_fields_order": [
    "sociallockup"
  ],
  "context_data_values": {
    "skin_tone": {
      "value": "fairLight",
      "id": "skinTone",
      "value_label": "Fair Light",
      "dimension_label": "Skin Tone"
    },
    "eye_color": {
      "value": "brown",
      "id": "eyeColor",
      "value_label": "Brown",
      "dimension_label": "Eye Color"
    },
    "staff_context": {
      "value": "false",
      "id": "StaffContext",
      "value_label": "No",
      "dimension_label": "I am a Sephora employee"
    },
    "skin_type": {
      "value": "oilySk",
      "id": "skinType",
      "value_label": "Oily",
      "dimension_label": "Skin Type"
    },
    "incentivized_review": {
      "value": "False",
      "id": "IncentivizedReview",
      "value_label": "No",
      "dimension_label": "I received this product as a free sample"
    },
    "skin_concerns": {
      "value": "acneBlemishes",
      "id": "skinConcerns",
      "value_label": "Acne/Blemishes",
      "dimension_label": "Skin Concerns"
    },
    "age_range": {
      "value": "20s",
      "id": "ageRange",
      "value_label": "20's",
      "dimension_label": "Age Range"
    }
  },
  "videos": [],
  "pros": null,
  "comment_ids": [],
  "photos": [],
  "user_location": null,
  "inappropriate_feedback_list": [],
  "secondary_ratings_order": [],
  "client_responses": [],
  "tag_dimensions": {},
  "product_recommendation_ids": [],
  "is_syndicated": false,
  "rating_range": 5,
  "helpfulness": null,
  "secondary_ratings": {},
  "cons": null,
  "tag_dimensions_order": []
}
```

**Core Identifiers:**

- **ID:** Unique review identifier for deduplication
- **Product ID:** Links review to specific product
- **Submission ID:** Alternative review identifier
- **Author ID:** User identifier (when available)

**Review Content:**

- **Title:** Review headline summarizing opinion
- **Review Text:** Full review body with detailed feedback
- **Rating:** Star rating (1-5 scale)
- **Is Recommended:** Boolean indicating product recommendation
- **Pros/Cons:** Structured lists of positives and negatives

**Engagement Metrics:**

- **Total Feedback Count:** Total helpfulness votes
- **Total Positive Feedback Count:** "Helpful" votes
- **Total Negative Feedback Count:** "Not helpful" votes
- **Helpfulness:** Calculated helpfulness score
- **Total Comment Count:** Replies to review
- **Total Client Response Count:** Brand responses

**Verification & Quality:**

- **Badges:** Verification badges (e.g., "Verified Purchase")
- **Is Featured:** Sephora-highlighted review
- **Moderation Status:** Review approval state
- **Is Syndicated:** Indicates syndicated content

**Temporal Data:**

- **Submission Time:** When review was posted
- **Last Modification Time:** Last edit timestamp
- **Last Moderated Time:** Moderation timestamp

**User Information:**

- **User Nickname:** Reviewer's display name
- **User Location:** Geographic location
- **Context Data Values:** Demographic data (skin type, age, etc.)

**Multimedia:**

- **Photos:** Array of customer-uploaded images
- **Videos:** Customer-uploaded video reviews

**Secondary Ratings:**

- Product-specific attribute ratings (e.g., "Longevity," "Application," "Value")

**Additional Context:**

- **Tag Dimensions:** Product attributes mentioned
- **Additional Fields:** Extended metadata
- **Source Client:** Review submission platform

### Step-by-Step Usage

**1. Collect Product URLs:** Browse Sephora categories or use search to find target products. Copy URLs from product pages. For competitive analysis, gather URLs from competitor brand pages.

**2. Configure Extraction:** Set `sort_by` based on needs (newest for trending sentiment, highest-rated for testimonials, lowest-rated for issues). Set `max_items_per_url` to 50-100 for comprehensive extraction.

**3. Handle Pagination:** For products with 500+ reviews, either:

- Run multiple times incrementing `offset` (0, 100, 200...)
- Set high `max_items_per_url` and let scraper paginate

**4. Run & Monitor:** Launch scraper. Check dataset preview to verify data quality. Typical extraction: 100 reviews in 1-2 minutes.

**5. Export & Analyze:** Export JSON for database integration or CSV for spreadsheet analysis. Filter by rating, date, or verification status for targeted analysis.

### Strategic Applications

**Product Performance Monitoring:** Track review volume, average ratings, and sentiment trends over time. Identify quality issues early through rating drops or negative review spikes.

**Competitive Intelligence:** Compare your products vs. competitors on secondary ratings (longevity, value, application). Identify features customers prefer in competitor products.

**Sentiment Analysis:** Process review text with NLP to extract common themes—ingredient concerns, shade matching issues, packaging complaints, scent preferences.

**Customer Insight Mining:** Analyze context data (skin type, age) to understand which demographics love or hate products. Tailor marketing to high-satisfaction segments.

**Feature Prioritization:** Extract pros/cons and tag dimensions to identify most-valued features and common complaints. Guide product development roadmaps.

**Review Response Strategy:** Identify high-visibility negative reviews (high helpfulness scores) requiring brand responses. Track `total_client_response_count` to measure engagement.

**Social Proof Extraction:** Pull verified, high-rated reviews with photos for marketing materials. Filter by `badges: ["Verified Purchase"]` and `photos: not empty`.

**Temporal Trend Analysis:** Sort by `submission_time` to track sentiment changes after reformulations, price changes, or marketing campaigns.

### Best Practices

**Schedule Regular Scraping:** Weekly extraction captures new reviews for trending sentiment. Monthly comprehensive scraping builds historical datasets.

**Segment by Rating:** Analyze 1-2 star vs. 4-5 star reviews separately. Low ratings reveal issues; high ratings identify strengths.

**Leverage Secondary Ratings:** Beauty products have attribute-specific ratings (longevity, value, application). These granular metrics reveal specific performance dimensions.

**Validate Verification:** Prioritize `badges: ["Verified Purchase"]` reviews for authenticity. Track verified vs. unverified ratios to assess review quality.

**Enrich with Product Data:** Combine review data with product information (price, ingredients, category) from product detail scrapers for comprehensive analysis.

**Monitor Helpfulness:** High `total_positive_feedback_count` reviews represent community consensus. Weight these more heavily in analysis.

**Track Review Velocity:** Sudden review volume spikes indicate viral moments, influencer mentions, or quality issues requiring immediate attention.

### Conclusion

The Sephora Product Reviews Scraper transforms customer feedback into actionable beauty market intelligence. From identifying product issues to extracting competitive insights, this tool delivers the customer voice data driving decisions in the $500B+ beauty industry. Start extracting Sephora review insights today.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the product details urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `sort_by` (type: `string`):

Sort Items by

## `offset` (type: `integer`):

Offset

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.sephora.com/product/diorshow-waterproof-mascara-P99901?skuId=838763&icid2=products%20grid:p99901:product"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.sephora.com/product/diorshow-waterproof-mascara-P99901?skuId=838763&icid2=products%20grid:p99901:product"
    ],
    "offset": 0,
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/sephora-product-reviews-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 = {
    "urls": ["https://www.sephora.com/product/diorshow-waterproof-mascara-P99901?skuId=838763&icid2=products%20grid:p99901:product"],
    "offset": 0,
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/sephora-product-reviews-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 '{
  "urls": [
    "https://www.sephora.com/product/diorshow-waterproof-mascara-P99901?skuId=838763&icid2=products%20grid:p99901:product"
  ],
  "offset": 0,
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/sephora-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sephora Product Reviews Scraper",
        "description": "Scrape comprehensive product reviews from Sephora.com including ratings, verified purchases, user feedback, and review metadata. Extract customer insights, sentiment data, and product performance metrics for beauty market research and competitive analysis.",
        "version": "0.0",
        "x-build-id": "V2GXaMl73KIFHyt5H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~sephora-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-sephora-product-reviews-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/stealth_mode~sephora-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-sephora-product-reviews-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/stealth_mode~sephora-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-sephora-product-reviews-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": {
                    "urls": {
                        "title": "URLs of the product details urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product details urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort_by": {
                        "title": "Sort by",
                        "enum": [
                            "",
                            "TotalPositiveFeedbackCount:desc",
                            "Rating:desc",
                            "Rating:asc",
                            "SubmissionTime:asc",
                            "SubmissionTime:desc"
                        ],
                        "type": "string",
                        "description": "Sort Items by"
                    },
                    "offset": {
                        "title": "Offset",
                        "type": "integer",
                        "description": "Offset"
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
