# Paris.cl Product Scraper (`automation-lab/paris-cl-product-scraper`) Actor

Scrape Paris.cl product listings for prices, SKUs, brands, availability, ratings, images, and product URLs from Chile ecommerce pages.

- **URL**: https://apify.com/automation-lab/paris-cl-product-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Paris.cl Product Scraper

Scrape product listings from Paris.cl, one of Chile's major ecommerce retailers, without building a custom crawler.

Use this actor to collect product URLs, SKUs, names, brands, prices, availability, images, ratings, review counts, categories, and listing positions from Paris.cl category and search pages.

### What does Paris.cl Product Scraper do?

Paris.cl Product Scraper turns public Paris.cl listing pages into structured data.

It works with category URLs such as `https://www.paris.cl/tecnologia/celulares/` and paginates through listing pages until it reaches your selected limits.

The actor is designed for price monitoring, assortment tracking, retail research, and Chile ecommerce intelligence.

### Who is it for?

🛒 **Marketplace sellers** can monitor competing products and price positions.

📈 **Ecommerce analysts** can track category assortment and pricing movements.

🏷️ **Brands and distributors** can audit product visibility, availability, and ratings.

🤖 **Data teams** can feed Paris.cl product data into dashboards, alerts, or enrichment pipelines.

### Why use this actor?

Paris.cl pages include rich server-rendered product metadata, but extracting it reliably still requires pagination, deduplication, schema normalization, retries, and dataset export handling.

This actor packages that workflow into a repeatable Apify run.

### What data can you extract?

| Field | Description |
| --- | --- |
| `productId` | Product identifier parsed from URL or SKU |
| `sku` | SKU from Paris.cl structured data |
| `title` | Product title |
| `brand` | Product brand when available |
| `url` | Product detail URL |
| `imageUrl` | Main image URL |
| `price` | Current listed price |
| `currency` | Currency, usually `CLP` |
| `availability` | Schema.org availability value |
| `inStock` | Boolean stock helper |
| `ratingValue` | Average rating when present |
| `reviewCount` | Review count when present |
| `category` | Last breadcrumb/category |
| `breadcrumbs` | Full breadcrumb trail |
| `position` | Position in the listing page |
| `pageNumber` | Listing page number |
| `sourceUrl` | URL that produced the item |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Paris.cl products?

The actor uses pay-per-event pricing.

There is a small run-start charge and a per-product result charge.

For example, a run that collects 1,000 products is intended to cost only a small ecommerce data fee while staying transparent: you pay for results extracted.

### Quick start

1. Open the actor on Apify.
2. Paste one or more Paris.cl category URLs.
3. Set `Maximum products` to a small value for the first run.
4. Start the actor.
5. Download results as JSON, CSV, Excel, XML, RSS, or HTML table.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.paris.cl/tecnologia/celulares/" }
  ],
  "maxResults": 50,
  "maxPagesPerUrl": 3,
  "maxRequestRetries": 3
}
````

### Input fields

#### Paris.cl listing URLs

Use category or search listing pages from `www.paris.cl`.

#### Optional search keyword

You can provide a keyword and the actor will build a Paris.cl search URL.

For the most stable results, category URLs are recommended.

#### Maximum products

Controls the total number of unique products saved.

#### Maximum pages per URL

Controls pagination depth for each supplied listing URL.

#### Max request retries

Controls retry attempts for temporary HTTP failures.

### Output example

```json
{
  "productId": "549926999",
  "sku": "549926999",
  "title": "iPhone 15 128GB Negro",
  "brand": "Apple",
  "url": "https://www.paris.cl/iphone-15-128gb-negro-549926999.html",
  "imageUrl": "https://cl-dam-resizer.ecomm.cencosud.com/unsafe/adaptive-fit-in/792x1068/paris/549926999/variant/images/example.jpg",
  "price": 649990,
  "currency": "CLP",
  "availability": "InStock",
  "inStock": true,
  "ratingValue": 4.68927,
  "reviewCount": 354,
  "category": "Celulares",
  "breadcrumbs": ["Tecno", "Celulares"],
  "position": 1,
  "pageNumber": 1,
  "sourceUrl": "https://www.paris.cl/tecnologia/celulares/",
  "scrapedAt": "2026-05-19T00:00:00.000Z"
}
```

### Tips for best results

✅ Start with one category URL and `maxResults` of 20.

✅ Use category URLs for broad assortment monitoring.

✅ Increase `maxPagesPerUrl` when you need deeper category coverage.

✅ Schedule runs daily or weekly to track price and stock changes over time.

✅ Keep the original `sourceUrl` field for debugging and dashboard segmentation.

### Integrations

Send results to Google Sheets for merchandising teams.

Export JSON to a warehouse such as BigQuery, Snowflake, or PostgreSQL.

Trigger alerts when `price` changes or `inStock` becomes false.

Combine the data with brand catalogs for Chilean market monitoring.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/paris-cl-product-scraper').call({
  startUrls: [{ url: 'https://www.paris.cl/tecnologia/celulares/' }],
  maxResults: 50,
  maxPagesPerUrl: 3
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/paris-cl-product-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.paris.cl/tecnologia/celulares/'}],
    'maxResults': 50,
    'maxPagesPerUrl': 3,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~paris-cl-product-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.paris.cl/tecnologia/celulares/"}],"maxResults":50,"maxPagesPerUrl":3}'
```

### MCP integration

Use this actor from Apify MCP tools in Claude Code or Claude Desktop.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/paris-cl-product-scraper`

Claude Code setup:

```bash
claude mcp add apify-paris-cl "https://mcp.apify.com/?tools=automation-lab/paris-cl-product-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-paris-cl": {
      "url": "https://mcp.apify.com/?tools=automation-lab/paris-cl-product-scraper"
    }
  }
}
```

Example prompts:

- "Run automation-lab/paris-cl-product-scraper for Paris.cl celulares and summarize the top brands."
- "Compare Paris.cl phone prices from today's dataset with yesterday's dataset."
- "Export Paris.cl products with price below 300000 CLP."

### Scheduling workflows

Set up a daily schedule to monitor prices.

Use one dataset per run for snapshots.

Compare snapshots by `sku`, `productId`, or `url`.

### Common use cases

Price intelligence for Chile retail.

Assortment tracking for categories such as electronics, appliances, toys, beauty, and home.

Stock availability monitoring.

Brand visibility reporting.

Product catalog enrichment.

### Limitations

The actor reads public listing metadata available in Paris.cl HTML.

Some optional fields may be missing for products that do not expose ratings, reviews, brand data, or availability.

If Paris.cl changes its page structure, extraction rules may need to be updated.

### Troubleshooting

#### Why did I get fewer products than requested?

The selected category may contain fewer public products, duplicate products across pages, or Paris.cl may return an empty page before your limit is reached.

#### Why is rating data missing for some products?

Not every product exposes aggregate rating metadata. Missing ratings are returned as `null`.

#### Should I use category URLs or search keywords?

Category URLs are recommended for stable monitoring. Search keywords are useful for ad hoc discovery.

### Data quality notes

Prices are numeric CLP values when exposed by Paris.cl structured data.

Availability is normalized from Schema.org values such as `InStock`.

URLs are absolute product URLs.

Images are direct media URLs when present.

### Legality

This actor extracts publicly available product listing information.

Use it responsibly, respect Apify and source website terms, and avoid collecting personal data.

For compliance-sensitive use cases, consult your legal team.

### Related scrapers

You may also be interested in other automation-lab ecommerce and marketplace actors on Apify.

Examples include generic product scrapers, marketplace price trackers, and shopping data tools.

Browse: https://apify.com/automation-lab/

### FAQ

#### Can I scrape any Paris.cl category?

Yes. Use a public Paris.cl listing or category URL and set sensible limits for the first run.

#### Does the actor scrape product detail pages?

The MVP focuses on listing data exposed in category/search pages. Product detail enrichment can be added later if users need it.

### Support

If a run fails or Paris.cl changes its layout, open an Apify issue with your input and run link.

Include the category URL, expected result count, and a short description of the problem.

### Changelog

Initial version extracts Paris.cl product listing metadata over HTTP.

### Dataset exports

Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, or HTML table.

Use CSV for spreadsheets.

Use JSON for pipelines.

Use Excel for merchandising reports.

### Performance

The actor is HTTP-only and does not launch a browser.

That keeps runs fast and inexpensive compared with browser automation.

Pagination stops automatically when no products are found or when limits are reached.

### Reliability

The actor retries failed HTTP requests.

It deduplicates products by product URL.

It records the source page and scrape timestamp for traceability.

# Actor input Schema

## `startUrls` (type: `array`):

Category or search result URLs from Paris.cl. Example: https://www.paris.cl/tecnologia/celulares/

## `searchQuery` (type: `string`):

Keyword to search on Paris.cl. Leave empty when using listing URLs only.

## `maxResults` (type: `integer`):

Stop after this many unique products have been saved.

## `maxPagesPerUrl` (type: `integer`):

How many paginated listing pages to request for each start URL.

## `maxRequestRetries` (type: `integer`):

Retry attempts for failed Paris.cl HTTP requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.paris.cl/tecnologia/celulares/"
    }
  ],
  "maxResults": 20,
  "maxPagesPerUrl": 2,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.paris.cl/tecnologia/celulares/"
        }
    ],
    "searchQuery": "",
    "maxResults": 20,
    "maxPagesPerUrl": 2,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/paris-cl-product-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 = {
    "startUrls": [{ "url": "https://www.paris.cl/tecnologia/celulares/" }],
    "searchQuery": "",
    "maxResults": 20,
    "maxPagesPerUrl": 2,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/paris-cl-product-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 '{
  "startUrls": [
    {
      "url": "https://www.paris.cl/tecnologia/celulares/"
    }
  ],
  "searchQuery": "",
  "maxResults": 20,
  "maxPagesPerUrl": 2,
  "maxRequestRetries": 3
}' |
apify call automation-lab/paris-cl-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Paris.cl Product Scraper",
        "description": "Scrape Paris.cl product listings for prices, SKUs, brands, availability, ratings, images, and product URLs from Chile ecommerce pages.",
        "version": "0.1",
        "x-build-id": "YNwr4C3m7qZmV6FJn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~paris-cl-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-paris-cl-product-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/automation-lab~paris-cl-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-paris-cl-product-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/automation-lab~paris-cl-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-paris-cl-product-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": {
                    "startUrls": {
                        "title": "Paris.cl listing URLs",
                        "type": "array",
                        "description": "Category or search result URLs from Paris.cl. Example: https://www.paris.cl/tecnologia/celulares/",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Optional search keyword",
                        "type": "string",
                        "description": "Keyword to search on Paris.cl. Leave empty when using listing URLs only."
                    },
                    "maxResults": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after this many unique products have been saved.",
                        "default": 50
                    },
                    "maxPagesPerUrl": {
                        "title": "Maximum pages per URL",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many paginated listing pages to request for each start URL.",
                        "default": 3
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Retry attempts for failed Paris.cl HTTP requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
