# Femaledaily Reviews Scraper (`stealth_mode/femaledaily-reviews-scraper`) Actor

Scrape detailed product reviews from Femaledaily.com with ease. Extract reviewer profiles, ratings, comments, photos, recommendations, and usage insights — perfect for beauty brand researchers, market analysts, and cosmetic product intelligence teams.

- **URL**: https://apify.com/stealth\_mode/femaledaily-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, 0 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

## Femaledaily Reviews Scraper: Extract Beauty Product Reviews at Scale

---

### What Is Femaledaily.com?

Femaledaily.com is one of Asia's largest beauty and cosmetics review platforms, hosting hundreds of thousands of user-generated product reviews. Beauty brands, retailers, and researchers rely on Femaledaily reviews to understand consumer sentiment, product performance, and market trends. Manually collecting review data is inefficient — the **Femaledaily Reviews Scraper** automates extraction, delivering structured reviewer insights and product feedback at scale.

---

### Overview

The **Femaledaily Reviews Scraper** extracts comprehensive product reviews from Femaledaily.com, converting unstructured feedback into machine-readable records. It captures reviewer demographics, ratings, photos, recommendations, and detailed comments — everything needed for sentiment analysis or product intelligence.

Ideal users include:

- **Beauty brands** monitoring consumer perception and product feedback
- **Market researchers** analyzing cosmetic product trends and competitor positioning
- **Sentiment analysts** building datasets for NLP and feedback analysis
- **E-commerce platforms** aggregating review data for product comparison tools
- **Retailers** tracking product performance across beauty categories

Key features include flexible filtering by skin type, age range, and review order; configurable item limits; and error resilience via `ignore_url_failures`.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "urls": [
    "https://reviews.femaledaily.com/products/cleanser/toner/viva-cosmetics/air-mawar?cat=&cat_id=0&age_range=&skin_type=&skin_tone=&skin_undertone=&hair_texture=&hair_type=&order=newest&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Configuration Parameters

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | Direct links to Femaledaily product review pages. Can include filter parameters for skin type, age range, tone, undertone, or sort order (newest, most helpful, etc.) |
| `max_items_per_url` | Integer | Maximum number of reviews to extract per URL (e.g., `200` for comprehensive collection) |
| `ignore_url_failures` | Boolean | If `true`, scraper continues if some URLs fail; if `false`, entire run stops on first error |

#### URL Structure

Femaledaily review URLs follow this pattern:

```
https://reviews.femaledaily.com/products/[category]/[subcategory]/[brand]/[product]
```

Optional query parameters allow filtering:

- `page=2` — target specific review pages
- `skin_type=oily` — filter by skin type
- `age_range=25-30` — filter by reviewer age
- `order=newest` or `order=most_helpful` — sort reviews
- `skin_tone=tan`, `skin_undertone=warm` — demographic filters

> **Tip:** Use filter parameters to collect reviews from specific user segments, enabling targeted market research.

***

### Output Format

**Sample output**

```json
{
  "id": 0,
  "reviewer_id": 2814310,
  "date": "2026-02-08T07:11:11.915Z",
  "text": "Produk dari viva ini ga usa di ragukan lagi deh bestieee.. baguss pol. \nBuat skin barier dan melebab kan kulit. \nProduk dr viva kebanyakan cocok di kulitku yang kering dan oily ini. \nMantaappp produk viva 🫶🏻\nSemoga tetap dan semakin berjaya yaaa",
  "is_like": false,
  "total_likes": 0,
  "total_comments": 0,
  "is_recommended": "y",
  "duration_of_use": "3 months - 6 months",
  "place_to_get": {
    "place": "Shopee",
    "order": [
      "Online",
      "E-Commerce",
      "Shopee"
    ],
    "is_freetext": false
  },
  "is_expand": false,
  "comment": "",
  "comments": {
    "data": [],
    "pagination": {}
  },
  "rating": {
    "average": 0,
    "user": 5,
    "total": 0
  },
  "user": {
    "id": 1743565,
    "username": "Miraayunanda",
    "is_verified": false,
    "picture": "http://image.femaledaily.com/dyn/480/images/user-pics/72acded3acd45e4c8b6ed680854b8ab1u43uwt1770533174790.jpeg",
    "age_range": "19 - 24",
    "info": "Dry Skin,19 - 24",
    "skin": {
      "type": "Dry",
      "tone": "Medium",
      "undertone": "Warm"
    }
  },
  "product": {
    "id": 2500,
    "image": "https://image.femaledaily.com/dyn/210/images/prod-pics/product_1630998319_307543_1_800x800.jpg",
    "name": "",
    "slug": "air-mawar",
    "shade": "",
    "brand": {
      "name": "Viva Cosmetics",
      "slug": "viva-cosmetics"
    },
    "category": {
      "name": "",
      "slug": "",
      "parent": {
        "name": "",
        "slug": ""
      }
    }
  },
  "photos": [
    {
      "img_url": "https://s3.ap-southeast-1.amazonaws.com/assets.femaledaily.com/images/user-review/imgfdn-6fba17c3-9690-4126-95b9-daa7767aa76b.jpg",
      "rvwr_image_id": 233328,
      "img_alt": "Air Mawar imgfdn-a4c924b2-4e70-47b4-bd1e-29b6a0cbb203",
      "rvwr_unique_code": "imgfdn-a4c924b2-4e70-47b4-bd1e-29b6a0cbb203"
    }
  ],
  "from_url": "https://reviews.femaledaily.com/products/cleanser/toner/viva-cosmetics/air-mawar?cat=&cat_id=0&age_range=&skin_type=&skin_tone=&skin_undertone=&hair_texture=&hair_type=&order=newest&page=2"
}
```

Each scraped review returns 17 fields capturing review metadata, content, and engagement:

#### Review Identity & Metadata

| Field | Meaning | Example |
|---|---|---|
| `ID` | Unique review identifier in the Femaledaily system | `"review_12345"` |
| `Reviewer ID` | Unique identifier for the user who posted the review | `"user_789"` |
| `Date` | Review submission date | `"2024-01-15"` |
| `Product` | Product name and metadata | `"Viva Cosmetics Air Mawar Toner"` |
| `User` | Reviewer's username and profile info | `"beauty_blogger_123"` |

#### Review Content

| Field | Meaning | Usage |
|---|---|---|
| `Text` | Main review body — detailed written feedback on product quality, effectiveness, and user experience | Sentiment analysis, feedback mining, product insights |
| `Comment` | Additional reviewer notes or follow-up comments | Context for review sentiment |
| `Comments` | Nested comments or replies from other users | Community engagement metrics |
| `Photos` | Array of review images uploaded by the reviewer | Visual product demonstrations, packaging photos |

#### Review Ratings & Recommendations

| Field | Meaning | Impact |
|---|---|---|
| `Rating` | Numerical score given by reviewer (typically 1–5 stars) | Overall satisfaction measurement, aggregation for average ratings |
| `Is Recommended` | Boolean flag: whether reviewer recommends the product | Purchase intent signal |
| `Is Like` | Boolean flag: whether reviewer marked the review as helpful/liked | Review credibility and usefulness |
| `Total Likes` | Count of other users who found this review helpful | Credibility ranking for review sorting |
| `Total Comments` | Number of community responses to the review | Engagement and discussion level |

#### Product Usage & Demographics

| Field | Meaning | Segmentation Value |
|---|---|---|
| `Duration Of Use` | How long the reviewer has used the product (e.g., "3 months", "1 year") | Product reliability and long-term satisfaction |
| `Place To Get` | Where reviewer purchased the product (online store, physical retail, etc.) | Channel performance insights |
| `Is Expand` | Indicates if the review was expanded/read in full by other users | Review relevance and visibility |

***

### How to Use

1. **Navigate Femaledaily** — Visit https://reviews.femaledaily.com and browse product reviews by category (cleansers, toners, serums, etc.).

2. **Copy review page URLs** — Find a product with reviews you want to extract. Copy the full URL, including any filter parameters (skin type, age range, sort order).

3. **Configure input JSON** — Paste URLs into the `urls` array. Set `max_items_per_url` based on your needs (e.g., `200` for all available reviews, `50` for a sample).

4. **Enable failure tolerance** — Set `ignore_url_failures: true` for bulk runs to skip broken links without interrupting the scrape.

5. **Execute the scraper** — Start the actor and monitor the run log for errors or completion status.

6. **Export & analyze** — Download results as JSON, CSV, or Excel. Use the data for sentiment analysis, competitive research, or trend identification.

**Handling common issues:**

- If a URL returns no reviews, verify it's a product review page (not a category listing).
- Use URL filters to narrow results before scraping, reducing quota usage.
- For large datasets, split URLs across multiple runs to improve reliability.

***

### Use Cases & Business Value

**Beauty brand teams** monitor how their products are perceived versus competitors, identifying strengths (long-lasting, affordable) and weaknesses (irritation, packaging).

**Market researchers** track emerging trends — e.g., increased demand for K-beauty ingredients or sustainable packaging — by analyzing review text and ratings over time.

**Product development** teams use feedback to guide formulation improvements and feature requests mentioned in reviews.

**E-commerce platforms** integrate review data into product cards, enriching search results and building customer confidence.

**Influencers and beauty bloggers** use Femaledaily review data to identify trending products and develop content strategies.

***

### Conclusion

The **Femaledaily Reviews Scraper** transforms raw review pages into actionable consumer intelligence. With 17 detailed data fields and flexible filtering, it enables brands, researchers, and retailers to understand market sentiment at scale — replacing hours of manual copying with instant, structured data exports.

# Actor input Schema

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

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

## `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://reviews.femaledaily.com/products/cleanser/toner/viva-cosmetics/air-mawar?cat=&cat_id=0&age_range=&skin_type=&skin_tone=&skin_undertone=&hair_texture=&hair_type=&order=newest&page=2"
  ],
  "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://reviews.femaledaily.com/products/cleanser/toner/viva-cosmetics/air-mawar?cat=&cat_id=0&age_range=&skin_type=&skin_tone=&skin_undertone=&hair_texture=&hair_type=&order=newest&page=2"
    ],
    "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/femaledaily-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://reviews.femaledaily.com/products/cleanser/toner/viva-cosmetics/air-mawar?cat=&cat_id=0&age_range=&skin_type=&skin_tone=&skin_undertone=&hair_texture=&hair_type=&order=newest&page=2"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/femaledaily-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://reviews.femaledaily.com/products/cleanser/toner/viva-cosmetics/air-mawar?cat=&cat_id=0&age_range=&skin_type=&skin_tone=&skin_undertone=&hair_texture=&hair_type=&order=newest&page=2"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call stealth_mode/femaledaily-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Femaledaily Reviews Scraper",
        "description": "Scrape detailed product reviews from Femaledaily.com with ease. Extract reviewer profiles, ratings, comments, photos, recommendations, and usage insights — perfect for beauty brand researchers, market analysts, and cosmetic product intelligence teams.",
        "version": "0.0",
        "x-build-id": "7it4UyjNHfTarjff7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~femaledaily-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-femaledaily-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~femaledaily-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-femaledaily-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~femaledaily-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-femaledaily-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 reviews urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the product reviews 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"
                        }
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
