# wallapop Scraper (`fayoussef/wallapop-scraper`) Actor

Scrape Wallapop listings at scale across Spain, Italy, and Portugal without writing a single line of code. Paste any Wallapop search URL or item URL, and this actor returns structured data for every listing prices, specs, seller info, images, and engagement metrics.

- **URL**: https://apify.com/fayoussef/wallapop-scraper.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 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.

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

## Wallapop Scraper — Extract Listings from Spain, France, Italy, Portugal & UK

Scrape Wallapop listings at scale across all five supported markets — Spain, France, Italy, Portugal, and the United Kingdom — without writing a single line of code. Paste any Wallapop search URL or item URL, and this actor returns structured data for every listing — prices, specs, seller business info, phone numbers, images, and engagement metrics.

### What you get

**Listing info**
- `title` — full listing title
- `listing_url` — direct URL to the listing
- `share_url` — shareable link
- `description` — seller's full description text
- `category` / `category_id` — listing category (e.g. Coches, Cars, Immobiliare)
- `slug` / `item_id` / `type` — internal identifiers
- `modified_date` — last updated timestamp

**Pricing**
- `price` — asking price (cash)
- `financed_price` — financed price, if different from cash price
- `currency` — always EUR

**Vehicle / item attributes**
- `brand`, `model`, `version`
- `year`, `km`, `engine`, `gear_box`, `body_type`
- `doors`, `seats`, `horse_power`, `eco_label`
- `extra_attributes` — any additional category-specific fields (e.g. warranty)

**Location**
- `city`, `postal_code`, `country_code`
- `latitude`, `longitude`

**Seller**
- `seller_id` — Wallapop internal seller ID
- `seller_is_top_profile` — whether the seller is a verified top profile
- `seller_legal_name` — registered business name (business sellers only)
- `seller_commercial_registry` — commercial registry entry
- `seller_registration_number` — VAT / business registration number
- `seller_email` — seller contact email
- `seller_phone` — seller phone number
- `seller_self_certification` — EU compliance declaration, if present

**Engagement**
- `views`, `favorites`, `conversations`

**Media**
- `images` — array of full-resolution image URLs
- `shipping_available` — whether the item ships

---

### Sample output

```json
{
  "title": "BMW Serie 2 Gran Tourer 218d Business",
  "price": 18890,
  "currency": "EUR",
  "financed_price": 18490,
  "listing_url": "https://fr.wallapop.com/item/bmw-serie-2-gran-tourer-218d-business-1239358058",
  "share_url": "https://wallapop.com/item/bmw-serie-2-gran-tourer-218d-business-1239358058",
  "brand": "BMW",
  "model": "Serie 2 Gran Tourer",
  "version": "218d Business",
  "year": 2020,
  "km": 114248,
  "engine": "Diesel",
  "gear_box": "Automatic",
  "body_type": "Minivan",
  "doors": 5,
  "seats": 5,
  "horse_power": 150,
  "eco_label": "C",
  "city": "Madrid",
  "postal_code": "28043",
  "country_code": "ES",
  "latitude": 40.462303,
  "longitude": -3.654690,
  "description": "BMW Serie 2 Gran Tourer 218d Business – Automático | 7 plazas | Muy equipado",
  "images": [
    "https://cdn.wallapop.com/images/10420/kh/vq/__/c10420p1239358058/i6368481882.jpg?pictureSize=W640",
    "https://cdn.wallapop.com/images/10420/kh/vq/__/c10420p1239358058/i6368481903.jpg?pictureSize=W640"
  ],
  "views": 52,
  "favorites": 3,
  "conversations": 0,
  "seller_id": "8x6q9kq5p5zy",
  "seller_is_top_profile": false,
  "seller_legal_name": "second cars luxury sl",
  "seller_commercial_registry": "second cars luxury",
  "seller_registration_number": "b67661009",
  "seller_email": "secondcarsluxury@gmail.com",
  "seller_phone": "912175139",
  "seller_self_certification": "This seller has declared to only offer products or services that comply with applicable European regulations.",
  "shipping_available": false,
  "category": "Cars",
  "category_id": "100",
  "extra_attributes": { "warranty": "12" },
  "item_id": "8j38g9o9pyz9",
  "slug": "bmw-serie-2-gran-tourer-218d-business-1239358058",
  "type": "car",
  "modified_date": 1776625796
}
````

***

### Use cases

- ✓ Used car dealers monitoring competitor pricing across Wallapop Spain and France daily
- ✓ Market research firms tracking second-hand goods pricing trends across Southern Europe and the UK
- ✓ Price comparison platforms aggregating listings from Wallapop Spain, Italy, and Portugal
- ✓ Individual resellers identifying underpriced inventory to flip across five markets
- ✓ Compliance and fraud teams verifying seller business registration numbers and EU certifications
- ✓ AI pipelines and agents needing structured Wallapop product and seller data via API

***

### Pricing

| Event | Price |
|---|---|
| 1,000 results scraped | $0.25 |
| 10,000 results | $2.50 |
| 100,000 results | $25.00 |

**Free tier:** Your first page of results is free on every run — no credit card needed to test.

Wallapop typically returns 20–40 items per search page. A full category scrape of 50,000 listings costs approximately **$12.50**.

***

### How it works

- **Input:** Paste one or more Wallapop search URLs or direct item URLs from any of the five supported markets (ES, FR, IT, PT, EN subdomains).
- **Geo anchoring:** If your URL contains no latitude/longitude, the actor automatically injects coordinates for the selected country (e.g. Spain → Madrid, France → Paris) so the API always returns geographically relevant results. You can override this with an exact lat/lng in the input.
- **Pagination:** The actor follows all search result pages automatically up to your configured limit.
- **Detail fetching:** For each listing, the actor fetches the full item detail API, the seller business info endpoint, and the seller phone number endpoint — all concurrently — returning every available field.
- **Output:** Results land in your Apify dataset, downloadable as JSON, CSV, or Excel instantly.
- **Scheduling:** Run on a schedule (hourly, daily, weekly) via Apify's built-in scheduler and push data to Google Sheets, Airtable, or any endpoint via webhooks.

***

### Why this scraper

- **Five markets, one actor:** Spain (`es.wallapop.com`), France (`fr.wallapop.com`), Italy (`it.wallapop.com`), Portugal (`pt.wallapop.com`), and the UK (`en.wallapop.com`) are detected automatically from the URL — no configuration needed.
- **Full seller business data:** Beyond basic listing fields, this actor fetches the seller-info and phone-number endpoints for every listing, returning legal names, registration numbers, emails, and phone numbers that standard scrapers miss entirely.
- **Full item detail, not just search snippets:** Every listing triggers a separate detail API call. You get all specs, all images, full descriptions, and engagement counters — not just what appears in search previews.
- **Resumable runs:** State is saved after every page. If a run is interrupted, it picks up exactly where it left off — no duplicate data, no lost pages.

***

### Input example

```json
{
  "start_urls": [
    { "url": "https://es.wallapop.com/search?category_id=100&time_filter=today&min_sale_price=4000&max_km=150000&seller_type=private&order_by=newest" }
  ],
  "max_items": 200,
  "country": "Spain"
}
```

Omit `max_items` to scrape all available results. Use `latitude` and `longitude` to override the default geo anchor for any country.

***

### FAQ

**Does it handle Wallapop's anti-bot protection?**
Yes. The actor uses residential proxies and rotates IPs automatically on failure, with up to 5 retries per request before logging an error.

**What output formats are available?**
JSON, CSV, Excel, and XML — all available directly from your Apify dataset without any extra steps.

**Can I scrape a specific item URL instead of a search?**
Yes. Paste any `wallapop.com/item/...` URL directly as a start URL and the actor returns the full detail record, including seller business info and phone number.

**Which markets are supported?**
Spain, France, Italy, Portugal, and the United Kingdom. The correct locale, Accept-Language headers, and geo coordinates are applied automatically based on the subdomain in your URL.

**Does it support scheduling?**
Yes. Use Apify's built-in scheduler to run the actor on any interval and combine it with webhooks to send data to external systems automatically.

**How fresh is the data?**
Data is fetched live on each run directly from Wallapop's API. There is no caching — every run reflects the current state of the listings at that moment.

**Can I filter results by price, location, or category?**
Yes — apply all filters directly in the Wallapop search URL before pasting it as input. The actor passes through all Wallapop URL parameters (price range, distance, brand, model, seller type, etc.).

**Can I use this with an AI agent or via API?**
Yes — see the section below.

***

### Use via API or MCP

Call this actor programmatically via the Apify REST API or connect it as an **MCP server** for AI agents (Claude, ChatGPT, Cursor, and others).

**API endpoint:**

```
POST https://api.apify.com/v2/acts/[PLACEHOLDER: your-apify-slug]/runs?token=YOUR_TOKEN
```

**MCP server URL:**

```
https://mcp.apify.com/actors/[PLACEHOLDER: your-apify-slug-with-tilde]
```

Replace `YOUR_TOKEN` with your Apify API token from the Apify console.

***

```
[PLACEHOLDERS]
- Actor Apify slug (e.g. yourname/wallapop-car-scraper) — needed for the API and MCP URLs above.
```

# Actor input Schema

## `start_urls` (type: `array`):

One or more Wallapop search or item detail URLs. Supports es/fr/it/de/pt/en subdomains.

## `max_items` (type: `integer`):

Stop after pushing this many items to the dataset (across all URLs and pages).

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

Used to set a default latitude/longitude when the search URL does not already contain coordinates. Each country maps to its capital or most relevant city (Spain→Madrid, France→Paris, Italy→Rome, Portugal→Lisbon, United Kingdom→London, Germany→Berlin). Ignored when 'Latitude' and 'Longitude' are both provided.

## `latitude` (type: `number`):

Custom latitude for the search centre. When set together with Longitude, overrides the country default. Useful for targeting a specific city or region regardless of the country selector.

## `longitude` (type: `number`):

Custom longitude for the search centre. Must be set together with Latitude.

## Actor input object example

```json
{
  "start_urls": [
    {
      "url": "https://es.wallapop.com/search?category_id=100&time_filter=today&min_sale_price=4000&max_km=150000&seller_type=private&order_by=newest"
    }
  ],
  "country": "Spain"
}
```

# Actor output Schema

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

Autoscout24 Scraper

# 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 = {
    "start_urls": [
        {
            "url": "https://es.wallapop.com/search?category_id=100&time_filter=today&min_sale_price=4000&max_km=150000&seller_type=private&order_by=newest"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/wallapop-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 = { "start_urls": [{ "url": "https://es.wallapop.com/search?category_id=100&time_filter=today&min_sale_price=4000&max_km=150000&seller_type=private&order_by=newest" }] }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/wallapop-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 '{
  "start_urls": [
    {
      "url": "https://es.wallapop.com/search?category_id=100&time_filter=today&min_sale_price=4000&max_km=150000&seller_type=private&order_by=newest"
    }
  ]
}' |
apify call fayoussef/wallapop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "wallapop Scraper",
        "description": "Scrape Wallapop listings at scale across Spain, Italy, and Portugal without writing a single line of code. Paste any Wallapop search URL or item URL, and this actor returns structured data for every listing prices, specs, seller info, images, and engagement metrics.",
        "version": "0.0",
        "x-build-id": "gRcaBzqrGKtEBXbe3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~wallapop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-wallapop-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/fayoussef~wallapop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-wallapop-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/fayoussef~wallapop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-wallapop-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",
                "required": [
                    "start_urls"
                ],
                "properties": {
                    "start_urls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more Wallapop search or item detail URLs. Supports es/fr/it/de/pt/en subdomains.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "max_items": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after pushing this many items to the dataset (across all URLs and pages)."
                    },
                    "country": {
                        "title": "Default Country",
                        "enum": [
                            "Spain",
                            "United Kingdom",
                            "France",
                            "Italy",
                            "Portugal",
                            "Germany"
                        ],
                        "type": "string",
                        "description": "Used to set a default latitude/longitude when the search URL does not already contain coordinates. Each country maps to its capital or most relevant city (Spain→Madrid, France→Paris, Italy→Rome, Portugal→Lisbon, United Kingdom→London, Germany→Berlin). Ignored when 'Latitude' and 'Longitude' are both provided.",
                        "default": "Spain"
                    },
                    "latitude": {
                        "title": "Latitude (optional override)",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Custom latitude for the search centre. When set together with Longitude, overrides the country default. Useful for targeting a specific city or region regardless of the country selector."
                    },
                    "longitude": {
                        "title": "Longitude (optional override)",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Custom longitude for the search centre. Must be set together with Latitude."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```