# Carousell Listings Scraper (`automation-lab/carousell-listings-scraper`) Actor

Scrape Carousell listings by keyword or search URL. Extract prices, sellers, conditions, images, listing IDs, URLs, and buyer-protection flags.

- **URL**: https://apify.com/automation-lab/carousell-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 6 total users, 3 monthly users, 99.5% runs succeeded, 0 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

## Carousell Listings Scraper

Extract public marketplace listings from Carousell search pages.

Use this actor to collect listing URLs, titles, prices, sellers, conditions, images, buyer-protection flags, and timestamps from Carousell markets such as Singapore, Malaysia, Philippines, Taiwan, Hong Kong, Indonesia, and global pages.

### What does Carousell Listings Scraper do?

Carousell Listings Scraper opens public Carousell search or category pages and saves visible listing cards into an Apify dataset.

It helps you turn Carousell search results into structured data for resale sourcing, marketplace monitoring, price comparisons, and lead discovery.

### Who is it for?

Marketplace resellers use it to monitor new deals.

Sourcing teams use it to track used-goods supply.

Price analysts use it to collect comps for consumer electronics, furniture, bikes, fashion, luxury goods, and more.

Local commerce teams use it to watch seller activity and category inventory.

### Why use this actor?

Carousell pages are dynamic and protected by Cloudflare.

This actor uses a browser workflow with Apify Proxy support and extracts fields from real rendered listing cards.

You get a clean dataset instead of manually copying search results.

### Data you can extract

| Field | Description |
| --- | --- |
| listingId | Carousell listing identifier |
| listingUrl | Public URL for the listing |
| title | Listing title |
| price | Display price |
| priceValue | Numeric price when parseable |
| currency | Currency prefix such as S$ |
| condition | Brand new, Like new, Lightly used, etc. |
| sellerName | Seller handle shown on the card |
| sellerProfileUrl | Public seller profile URL |
| postedAt | Relative listing timestamp |
| imageUrl | Main listing image |
| isBuyerProtection | Buyer Protection badge flag |
| likesCount | Visible like count when present |
| sourceUrl | Search or category page used |
| searchQuery | Search keyword parsed from the URL |
| scrapedAt | Extraction timestamp |

### How much does it cost to scrape Carousell listings?

The actor uses pay-per-event pricing.

You pay a small start fee and then a per-listing result fee.

Actual cost depends on your selected maximum listings and proxy usage.

For cheap tests, start with 10-20 listings.

### Quick start

1. Open the actor on Apify.
2. Enter one or more Carousell keywords, such as `bicycle` or `iphone`.
3. Keep the market set to Singapore for the default example.
4. Set `Maximum listings` to a small number for the first run.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Input options

`keywords` builds Carousell search URLs automatically.

`startUrls` accepts existing Carousell search or category URLs.

`maxItems` controls total listings saved across all inputs.

`market` chooses the Carousell domain for keyword searches.

`sortBy` appends a sort preference when supported by the target market.

`proxyType` controls Apify Proxy usage.

`timeoutSecs` adjusts browser page-load timeout.

### Example input

```json
{
  "keywords": ["bicycle"],
  "maxItems": 20,
  "market": "sg",
  "proxyType": "residential"
}
````

### Search URL example

```json
{
  "startUrls": [
    { "url": "https://www.carousell.sg/search/camera/" }
  ],
  "maxItems": 25,
  "proxyType": "residential"
}
```

### Example output

```json
{
  "listingId": "1447171463",
  "listingUrl": "https://www.carousell.sg/p/example-1447171463/",
  "sourceUrl": "https://www.carousell.sg/search/bicycle/",
  "searchQuery": "bicycle",
  "title": "Mavic Cosmic CXR60 carbon wheelset",
  "price": "S$800",
  "priceValue": 800,
  "currency": "S$",
  "condition": "Lightly used",
  "sellerName": "trustbikes",
  "sellerProfileUrl": "https://www.carousell.sg/u/trustbikes/",
  "postedAt": "6 minutes ago",
  "imageUrl": "https://media.karousell.com/media/photos/products/example.jpg",
  "isBuyerProtection": true,
  "likesCount": null,
  "scrapedAt": "2026-07-02T07:30:00.000Z"
}
```

### Tips for better results

Use specific search terms.

Prefer `iphone 15 pro` over `phone` when monitoring a product model.

Use `startUrls` when you already applied filters on Carousell.

Keep result limits realistic.

Run recurring tasks to monitor new listings over time.

### Proxy guidance

Carousell commonly challenges direct and datacenter traffic.

Residential proxy is the recommended default.

Datacenter proxy is available as an advanced option, but it may return a Cloudflare verification page instead of listings.

### Integrations

Export datasets to Google Sheets for price tracking.

Send JSON to a pricing pipeline for comps analysis.

Connect with Make or Zapier to notify buyers when new listings match a keyword.

Use Apify API webhooks to trigger downstream enrichment.

### 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/carousell-listings-scraper').call({
  keywords: ['bicycle'],
  maxItems: 20,
  market: 'sg',
  proxyType: 'residential'
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/carousell-listings-scraper').call(run_input={
    'keywords': ['bicycle'],
    'maxItems': 20,
    'market': 'sg',
    'proxyType': 'residential',
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~carousell-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["bicycle"],"maxItems":20,"market":"sg","proxyType":"residential"}'
```

### MCP usage

Use this actor through Apify MCP in Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/carousell-listings-scraper
```

Claude Code setup:

```bash
claude mcp add apify-carousell "https://mcp.apify.com/?tools=automation-lab/carousell-listings-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

```text
Scrape 20 Carousell Singapore bicycle listings and summarize median price by condition.
Find used iPhone listings on Carousell and return seller, price, condition, and URL.
```

### Monitoring workflows

Schedule the actor daily for important keywords.

Compare new dataset exports against yesterday's run.

Alert when a listing price drops below your target.

Track seller inventory for sourcing opportunities.

### Common use cases

Used iPhone price monitoring.

Bike and parts sourcing.

Furniture resale research.

Luxury goods market checks.

Local competitor monitoring.

### Legality and responsible use

This actor extracts publicly visible information from Carousell pages.

Respect Carousell terms, privacy rules, and applicable laws.

Do not use scraped data for spam, harassment, or unlawful profiling.

Reduce run frequency and result volume when you do not need large datasets.

### Troubleshooting

If a run returns zero results, try a broader keyword or a Carousell search URL that visibly has listings.

If the actor reports a security verification page, switch `proxyType` back to `residential` and retry with a lower `maxItems`.

If some optional fields are null, the field was not visible in the search card without opening detail pages.

### FAQ

#### Why does the actor use residential proxy by default?

Carousell commonly serves Cloudflare verification to direct and datacenter traffic. Residential proxy gives the actor the best chance to load public listing cards.

#### Can it scrape full listing detail pages?

This first version focuses on search-card data because opening every detail page is slower, more expensive, and more likely to trigger anti-bot checks.

#### Which Carousell markets are supported?

Keyword searches support Singapore, Malaysia, Philippines, Taiwan, Hong Kong, Indonesia, and global Carousell domains.

### Limitations

The actor extracts search-card data, not full private seller details.

Listing descriptions and exact location are often not visible on search cards.

The Carousell UI can change; selectors may need updates if card markup changes.

### Related scrapers

Explore other Automation Lab marketplace and ecommerce scrapers on Apify:

- https://apify.com/automation-lab/facebook-marketplace-scraper
- https://apify.com/automation-lab/ebay-scraper
- https://apify.com/automation-lab/etsy-scraper
- https://apify.com/automation-lab/shopify-products-scraper

### Support

If a Carousell page stops working, include the run URL, input, and the target Carousell URL when reporting an issue.

### Changelog

Initial version extracts listing cards from Carousell search and category pages with residential proxy support.

# Actor input Schema

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

Marketplace search phrases to scrape on Carousell, for example iphone, bicycle, sofa, or camera lens.

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

Optional Carousell search or category URLs. Use this when you already have a filtered Carousell page.

## `maxItems` (type: `integer`):

Maximum number of listings to save across all keywords and URLs.

## `market` (type: `string`):

Market domain used when building keyword search URLs.

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

Sort parameter to append to keyword search URLs. Availability can vary by market.

## `proxyType` (type: `string`):

Residential proxy is recommended. Carousell consistently returns Cloudflare challenges to direct and datacenter traffic.

## `timeoutSecs` (type: `integer`):

Maximum time for each Carousell page load.

## Actor input object example

```json
{
  "keywords": [
    "bicycle"
  ],
  "startUrls": [
    {
      "url": "https://www.carousell.sg/search/bicycle/"
    }
  ],
  "maxItems": 20,
  "market": "sg",
  "sortBy": "best_match",
  "proxyType": "residential",
  "timeoutSecs": 75
}
```

# 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 = {
    "keywords": [
        "bicycle"
    ],
    "startUrls": [
        {
            "url": "https://www.carousell.sg/search/bicycle/"
        }
    ],
    "maxItems": 20,
    "market": "sg",
    "sortBy": "best_match",
    "proxyType": "residential",
    "timeoutSecs": 75
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/carousell-listings-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 = {
    "keywords": ["bicycle"],
    "startUrls": [{ "url": "https://www.carousell.sg/search/bicycle/" }],
    "maxItems": 20,
    "market": "sg",
    "sortBy": "best_match",
    "proxyType": "residential",
    "timeoutSecs": 75,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/carousell-listings-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 '{
  "keywords": [
    "bicycle"
  ],
  "startUrls": [
    {
      "url": "https://www.carousell.sg/search/bicycle/"
    }
  ],
  "maxItems": 20,
  "market": "sg",
  "sortBy": "best_match",
  "proxyType": "residential",
  "timeoutSecs": 75
}' |
apify call automation-lab/carousell-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Carousell Listings Scraper",
        "description": "Scrape Carousell listings by keyword or search URL. Extract prices, sellers, conditions, images, listing IDs, URLs, and buyer-protection flags.",
        "version": "0.1",
        "x-build-id": "ByitDh0ZbD29Urxjk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~carousell-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-carousell-listings-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~carousell-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-carousell-listings-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~carousell-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-carousell-listings-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": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Marketplace search phrases to scrape on Carousell, for example iphone, bicycle, sofa, or camera lens.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Carousell search/category URLs",
                        "type": "array",
                        "description": "Optional Carousell search or category URLs. Use this when you already have a filtered Carousell page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of listings to save across all keywords and URLs.",
                        "default": 20
                    },
                    "market": {
                        "title": "Carousell market",
                        "enum": [
                            "sg",
                            "my",
                            "ph",
                            "tw",
                            "hk",
                            "id",
                            "com"
                        ],
                        "type": "string",
                        "description": "Market domain used when building keyword search URLs.",
                        "default": "sg"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "best_match",
                            "recent",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "Sort parameter to append to keyword search URLs. Availability can vary by market.",
                        "default": "best_match"
                    },
                    "proxyType": {
                        "title": "Proxy type",
                        "enum": [
                            "residential",
                            "datacenter",
                            "none"
                        ],
                        "type": "string",
                        "description": "Residential proxy is recommended. Carousell consistently returns Cloudflare challenges to direct and datacenter traffic.",
                        "default": "residential"
                    },
                    "timeoutSecs": {
                        "title": "Page timeout (seconds)",
                        "minimum": 30,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time for each Carousell page load.",
                        "default": 75
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```