# Wallapop Scraper | Spanish Secondhand Marketplace (`parseforge/wallapop-scraper`) Actor

Scrape Wallapop listings for clothes, electronics, cars, furniture, and more with title, price, location, seller, condition, photos, and description. Monitor Spanish-speaking secondhand markets across Spain and Europe for resale, pricing intel, and trend research projects.

- **URL**: https://apify.com/parseforge/wallapop-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛍️ Wallapop Marketplace Scraper

> 🚀 **Export Wallapop second-hand listings to CSV, Excel, JSON, or XML in seconds.** No account needed. No API key required.

> 🕒 **Last updated:** 2026-05-22 · **📊 14 fields** per record · **Up to 1,000,000 listings** · **7 European countries**

Wallapop is Europe's largest peer-to-peer marketplace for second-hand goods, with tens of millions of listings across Spain, Italy, France, Germany, Portugal, the Netherlands, and Belgium. This Actor searches Wallapop by keyword and country, enriches each listing with item condition and seller details from the item detail API, and delivers a clean structured dataset.

Data is fetched live from Wallapop's public REST API. Every run produces real-time listings for your search term.

**Coverage:** 7 European countries (ES, IT, PT, FR, DE, NL, BE) with 4 sort orders (relevance, newest, price ascending, price descending). Each record includes the listing photo, title, description, price, currency, condition, category, city, country, seller ID, seller name, listing URL, and post date.

### 🎯 Target Audience / Use Cases

| Who uses this | What they do with it |
|---|---|
| Resellers and flippers | Monitor Wallapop for underpriced items to buy and resell |
| Price comparison tools | Aggregate second-hand prices for consumer goods in Europe |
| Market researchers | Track pricing trends in the European second-hand market |
| Circular economy analysts | Study peer-to-peer commerce patterns across EU countries |
| Developers | Build deal alert apps and second-hand price trackers |
| Sellers | Research competitor pricing before listing their own items |

### 📋 What the Wallapop Marketplace Scraper does

- Searches Wallapop by keyword across 7 European countries
- Applies country-specific GPS coordinates for accurate local results
- Supports 4 sort orders: most relevant, newest, price low-to-high, price high-to-low
- Fetches item detail pages to extract condition and additional attributes
- Fetches seller profiles to include the seller name with each listing
- Paginates automatically through result pages until `maxItems` is reached

> 💡 **Why it matters:** Wallapop has no public search API for external data access. Manually monitoring listings for specific items across multiple European countries is slow and error-prone. This Actor automates the entire process using Wallapop's internal API and delivers a structured, enriched dataset in minutes.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

<table>
  <thead>
    <tr><th>Field</th><th>Type</th><th>Required</th><th>Default</th><th>Description</th></tr>
  </thead>
  <tbody>
    <tr><td><b>keywords</b></td><td>string</td><td>Yes</td><td>laptop</td><td>Search keywords (e.g. "iphone 14", "bicicleta", "sofa")</td></tr>
    <tr><td><b>maxItems</b></td><td>integer</td><td>No</td><td>10</td><td>Max listings to collect. Free: 10. Paid: up to 1,000,000.</td></tr>
    <tr><td><b>countryCode</b></td><td>select</td><td>No</td><td>ES</td><td>Country: Spain, Italy, Portugal, France, Germany, Netherlands, Belgium</td></tr>
    <tr><td><b>orderBy</b></td><td>select</td><td>No</td><td>most_relevance</td><td>Sort: Most Relevant, Newest First, Price Low to High, Price High to Low</td></tr>
  </tbody>
</table>

**Example 1 - Search for laptops in Spain sorted by price:**
```json
{
  "keywords": "laptop",
  "countryCode": "ES",
  "orderBy": "price_low_to_high",
  "maxItems": 100
}
````

**Example 2 - Search for iPhones in Italy, newest first:**

```json
{
  "keywords": "iphone 14",
  "countryCode": "IT",
  "orderBy": "newest",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Wallapop uses location-based search. The Actor automatically applies the country's capital city coordinates so results reflect listings across the whole country. Searches in non-Spanish countries may return fewer results as Wallapop's user base is largest in Spain.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ imageUrl | string | Listing primary photo URL |
| 📌 title | string | Listing title |
| 📝 description | string | Item description text |
| 💰 price | number | Asking price (numeric) |
| 💱 currency | string | Currency code (e.g. EUR) |
| 🔍 condition | string | Item condition: new, like new, good, fair, has defects |
| 🗂️ category | string | Item category from Wallapop's taxonomy |
| 📍 location | string | City where the item is located |
| 🌍 country | string | Country code (e.g. ES, IT, FR) |
| 👤 sellerId | string | Wallapop seller user ID |
| 🧑 sellerName | string | Seller's display name |
| 🆔 listingId | string | Wallapop internal item ID |
| 🔗 listingUrl | string | Direct URL to the Wallapop listing |
| 📅 postedAt | string | ISO timestamp when the listing was posted |
| 🕒 scrapedAt | string | ISO timestamp when this record was collected |

**Sample record:**

```json
{
  "imageUrl": "https://cdn.wallapop.com/images/10420/ab/cd/i1234567890.jpg?pictureSize=W640",
  "title": "MacBook Pro 14 M1 Pro - Como nuevo",
  "description": "Vendo MacBook Pro 14 pulgadas con chip M1 Pro...",
  "price": 1200,
  "currency": "EUR",
  "condition": "like new",
  "category": "Informatica",
  "location": "Barcelona",
  "country": "ES",
  "sellerId": "u1234567",
  "sellerName": "Carlos M.",
  "listingId": "i1234567890",
  "listingUrl": "https://wallapop.com/item/macbook-pro-14-m1-pro-i1234567890",
  "postedAt": "2026-05-20T14:30:00.000Z",
  "scrapedAt": "2026-05-22T09:15:00.000Z"
}
```

### ✨ Why choose this Actor

- 🌍 **7 European countries** - ES, IT, PT, FR, DE, NL, BE
- 🔍 **Condition data** - new, like new, good, fair, has defects for every listing
- 👤 **Seller profiles** - name included for every listing
- 📝 **Full descriptions** - complete item description text
- 🗂️ **Category taxonomy** - Wallapop's hierarchical category for each item
- 📅 **Post dates** - know exactly when each listing was published
- 🔄 **4 sort orders** - relevance, newest, price ascending, price descending

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Other scrapers |
|---|---|---|---|
| 7 EU countries | Yes | Yes (tedious) | Rarely |
| Item condition | Yes | Yes | Rarely |
| Seller names | Yes | Yes | Rarely |
| Full descriptions | Yes | Yes | Sometimes |
| Post dates | Yes | Yes | Sometimes |
| Sort by price/newest | Yes | Yes | Sometimes |
| Export to CSV/Excel | Yes | No | Sometimes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the Wallapop Marketplace Scraper on Apify Store
3. Enter your search keywords, country, and sort order
4. Set `maxItems` (free users get 10 items automatically)
5. Click **Save & Run**
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Reselling and arbitrage across Europe

Monitor Wallapop for underpriced electronics, collectibles, or furniture in Spain, Italy, and France. Automate daily searches to be first to spot deals.

#### Second-hand price benchmarking

Research what consumers are paying for used goods in different European markets. Compare iPhone prices in Spain vs Italy vs France.

#### Circular economy analytics

Study the second-hand market for specific product categories across Europe. Track volume, average prices, and condition distribution.

#### Seller competitive analysis

Before listing your item, research what similar items are selling for and at what condition. Price competitively from the start.

### 🔌 Automating Wallapop Scraper

- **Make (formerly Integromat)** - schedule daily deal alerts to your email or Slack
- **Zapier** - notify your team when a specific item appears below a target price
- **Apify Scheduler** - run automatic hourly or daily searches for hot categories
- **REST API** - trigger runs from your own deal monitoring application
- **Webhooks** - push new listings directly to your notification system

### 🌟 Beyond business use cases

#### Sustainability research

Study consumption patterns in the second-hand economy. Which categories see the most peer-to-peer resale activity? How does condition distribution vary by country?

#### Personal shopping

Track the price of a specific item you want to buy. Run weekly searches and wait for the right price and condition to appear.

#### Academic research

Investigate informal market economics, circular economy adoption across EU countries, or pricing behavior in peer-to-peer marketplaces.

#### Journalism

Report on the growth of second-hand commerce in Europe, product categories driving the circular economy, or seller behavior patterns.

### 🤖 Ask an AI assistant about this scraper

You can ask any AI assistant questions like:

- "What fields does the Wallapop Scraper return?"
- "How do I search for items in France?"
- "What condition values can the `condition` field have?"
- "Can I sort results by newest listing first?"

### ❓ Frequently Asked Questions

**Q: Which countries does Wallapop operate in?**
A: Spain, Italy, Portugal, France, Germany, the Netherlands, and Belgium. Spain has the largest catalog.

**Q: What condition values are possible?**
A: new, like new, good, fair, has defects. These are normalized from Wallapop's internal condition codes.

**Q: Does the Actor search local listings or national listings?**
A: The Actor uses capital city coordinates to anchor the search, but Wallapop's API returns listings from across the country, not just the capital.

**Q: Do I need a Wallapop account?**
A: No. All data is fetched from Wallapop's public API without login.

**Q: Can I search in languages other than English?**
A: Yes. Enter keywords in the local language for best results (e.g. "bicicleta" for bike in Spanish, "portátil" for laptop).

**Q: How many results can I collect?**
A: Free users get up to 10. Paid users can collect up to 1,000,000.

**Q: Is the data real-time?**
A: Yes. Every run fetches live data from Wallapop's API.

**Q: What is the `postedAt` field?**
A: The ISO timestamp when the seller originally posted the listing on Wallapop.

**Q: Can I filter by price range?**
A: The Actor does not currently support price range filtering in the input. You can filter by price in your spreadsheet or database after downloading.

**Q: Why does the Actor fetch item detail pages?**
A: The search API does not include item condition. A separate detail API call per item is needed to retrieve the condition field.

### 🔌 Integrate with any app

Export your Wallapop dataset to:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable\
**Databases:** PostgreSQL, MySQL, MongoDB, Snowflake\
**BI tools:** Tableau, Power BI, Looker, Metabase\
**Automation:** Make, Zapier, n8n, Pipedream\
**Storage:** AWS S3, Google Cloud Storage, Azure Blob\
**Notifications:** Slack, Discord, email via webhook

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Craigslist Scraper](https://apify.com/parseforge/craigslist-scraper) | Scrape second-hand classifieds from Craigslist across all US cities |
| [BizBuySell Scraper](https://apify.com/parseforge/bizbuysell-scraper-v2) | Export business-for-sale listings from BizBuySell |
| [Auction.com Property Scraper](https://apify.com/parseforge/auction-com-property-scraper) | Scrape foreclosure and bank-owned property listings |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ ready-to-use data scrapers across real estate, jobs, travel, finance, and more.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

***

> **⚠️ Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or associated with Wallapop. Use of this tool must comply with Wallapop's Terms of Use and applicable laws. The data collected is publicly available. ParseForge is not responsible for how collected data is used.

# Actor input Schema

## `keywords` (type: `string`):

Keywords to search for (e.g. 'laptop', 'iphone 14', 'bicicleta')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `countryCode` (type: `string`):

Country to search in

## `orderBy` (type: `string`):

Sort results by relevance, newest, or lowest/highest price

## Actor input object example

```json
{
  "keywords": "laptop",
  "maxItems": 10,
  "countryCode": "ES",
  "orderBy": "most_relevance"
}
```

# Actor output Schema

## `results` (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": "laptop",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "keywords": "laptop",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "keywords": "laptop",
  "maxItems": 10
}' |
apify call parseforge/wallapop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wallapop Scraper | Spanish Secondhand Marketplace",
        "description": "Scrape Wallapop listings for clothes, electronics, cars, furniture, and more with title, price, location, seller, condition, photos, and description. Monitor Spanish-speaking secondhand markets across Spain and Europe for resale, pricing intel, and trend research projects.",
        "version": "0.1",
        "x-build-id": "vKDU0SUqoaoJYmIPH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~wallapop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~wallapop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~wallapop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "string",
                        "description": "Keywords to search for (e.g. 'laptop', 'iphone 14', 'bicicleta')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "countryCode": {
                        "title": "Country",
                        "enum": [
                            "ES",
                            "IT",
                            "PT",
                            "FR",
                            "DE",
                            "NL",
                            "BE"
                        ],
                        "type": "string",
                        "description": "Country to search in",
                        "default": "ES"
                    },
                    "orderBy": {
                        "title": "Sort Order",
                        "enum": [
                            "most_relevance",
                            "newest",
                            "price_low_to_high",
                            "price_high_to_low"
                        ],
                        "type": "string",
                        "description": "Sort results by relevance, newest, or lowest/highest price",
                        "default": "most_relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
