# Swappa Scraper | Used Electronics Marketplace (`parseforge/swappa-scraper`) Actor

Scrape Swappa listings for used phones, laptops, tablets, and watches with model, condition, carrier, storage, price, seller rating, and photos. Track resale prices and inventory for arbitrage, market research, and competitive intelligence in the used electronics market.

- **URL**: https://apify.com/parseforge/swappa-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)

## 📱 Swappa Scraper

> 🚀 **Export used and refurbished tech listings from Swappa in seconds.** Search by keyword or category and download a clean dataset of prices, conditions, sellers, and specs.

> 🕒 **Last updated:** 2026-05-21 · **📊 16 fields** per record · **Thousands of listings** · **Phones, Laptops, Tablets & More**

Swappa is one of the most trusted peer-to-peer marketplaces for used consumer electronics in the United States. This actor lets you extract individual for-sale listings directly from Swappa - real prices from real sellers - for any device you search for.

Each record includes the listing image, device title, brand, model, asking price, condition rating, storage capacity, color, carrier compatibility, seller name, seller feedback count, and seller location.

### Coverage

Swappa hosts tens of thousands of active listings across cell phones, laptops, tablets, smartwatches, gaming consoles, cameras, and more. This scraper accesses all categories and returns up to 1,000,000 listings per run for paid users.

| Audience | Use Case |
|---|---|
| Resellers | Monitor competitor pricing and find arbitrage opportunities |
| Consumers | Compare used device prices before buying |
| Market analysts | Track pricing trends for specific models over time |
| Price comparison sites | Power used-device price indexes |
| Journalists | Report on the used electronics market |
| Sustainability researchers | Quantify the refurbished device ecosystem |

### 📋 What the Swappa Scraper does

- Searches Swappa by keyword (e.g. "iphone 13", "macbook pro", "ps5")
- Browses by category (Cell Phones, Laptops, Tablets, etc.)
- Filters by condition (Mint, Good, Fair)
- Extracts all listing fields: price, condition, storage, color, carrier, seller info, location
- Paginates through all results automatically
- Exports data as JSON, CSV, Excel, or XML

> 💡 **Why it matters:** Swappa is the go-to marketplace for vetted used devices. Unlike eBay, every listing is reviewed before going live. This makes Swappa price data uniquely reliable for market research and price comparison.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Description | Default |
|---|---|---|---|
| `searchQuery` | String | Keyword to search (e.g. "iphone 13", "macbook") | `iphone 13` |
| `maxItems` | Number | Max listings to collect (free: 10, paid: up to 1M) | `10` |
| `category` | Select | Category to browse when no search query | `cell-phones` |
| `condition` | Select | Filter by device condition | Any |

**Example - Search by keyword:**
```json
{
  "searchQuery": "iphone 13",
  "maxItems": 100
}
````

**Example - Browse category with condition filter:**

```json
{
  "searchQuery": "",
  "category": "laptops",
  "condition": "mint",
  "maxItems": 200
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 listings per run. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 listings.

### 📊 Output

Each listing includes these fields:

| Field | Description | Example |
|---|---|---|
| 🖼️ `imageUrl` | Primary listing photo | `https://static.swappa.com/...jpg` |
| 📝 `title` | Full device title | `Apple iPhone 13` |
| 🏷️ `brand` | Device manufacturer | `Apple` |
| 📱 `model` | Model name | `iphone 13` |
| 🔗 `url` | Link to Swappa listing | `https://swappa.com/listing/view/LAFJ35786` |
| 🆔 `id` | Swappa listing code | `LAFJ35786` |
| 💲 `price` | Asking price in USD | `$159` |
| ✅ `condition` | Device condition | `Fair` |
| 💾 `storage` | Storage capacity | `128 GB` |
| 🎨 `color` | Device color | `Midnight` |
| 📡 `carrier` | Carrier compatibility | `Unlocked` |
| 👤 `seller` | Seller name | `Dibcote LLC` |
| ⭐ `sellerRating` | Number of seller ratings | `45` |
| 📍 `location` | Seller location | `Kansas City, MO` |
| 🗂️ `category` | Swappa model category | `apple-iphone-13` |
| 🕒 `scrapedAt` | ISO timestamp | `2026-05-22T01:28:50.618Z` |
| ❌ `error` | Error message if any | `null` |

**Sample records:**

```json
[
  {
    "imageUrl": "https://static.swappa.com/images/cache/9e/a1/9ea1b7d1facde50363b948c9bd5acb0d.jpg",
    "title": "Apple iPhone 13",
    "brand": "Apple",
    "model": "iphone 13",
    "url": "https://swappa.com/listing/view/LAFJ35786",
    "id": "LAFJ35786",
    "price": "$159",
    "condition": "Fair",
    "storage": "128 GB",
    "color": "Midnight",
    "carrier": "Bell Canada",
    "seller": "Dibcote LLC",
    "sellerRating": "45",
    "location": "Kansas City, MO",
    "category": "apple-iphone-13",
    "scrapedAt": "2026-05-22T01:28:50.618Z",
    "error": null
  },
  {
    "imageUrl": "https://static.swappa.com/images/cache/37/95/37954fc5a4d7c5ba6186a8f5bb65b945.jpg",
    "title": "Apple iPhone 13",
    "brand": "Apple",
    "model": "iphone 13",
    "url": "https://swappa.com/listing/view/LZFI62483",
    "id": "LZFI62483",
    "price": "$219",
    "condition": "Good",
    "storage": "128 GB",
    "color": "Midnight",
    "carrier": "AT&T",
    "seller": "Tech Gallery",
    "sellerRating": "1025",
    "location": "Garden City, MI",
    "category": "apple-iphone-13",
    "scrapedAt": "2026-05-22T01:28:50.619Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🚀 Real-time data | Every run pulls live listings - no stale cache |
| 🛡️ Cloudflare bypass | Residential proxy + stealth browser for reliable access |
| 📊 Rich fields | 16 fields per listing including seller stats and location |
| 🔍 Flexible search | Search by keyword or browse by category and condition |
| 📄 Multiple formats | Download as JSON, CSV, Excel, or XML |
| 💰 Fair pricing | Pay per result - only charged for successful data |

### 📈 How it compares to alternatives

| Feature | Swappa Scraper | Manual browsing | Other scrapers |
|---|---|---|---|
| Scale | Up to 1M listings | Dozens per hour | Varies |
| Data format | JSON/CSV/Excel/XML | None | Often JSON only |
| Condition filter | Yes | Yes | Rare |
| Seller info | Yes | Yes | Rare |
| Cloudflare bypass | Yes | N/A | Often fails |
| Maintenance | Active | N/A | Often abandoned |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the **Swappa Scraper** actor
3. Enter a search query like `iphone 13` or select a category
4. Set `maxItems` to the number of listings you want
5. Click **Run** and wait for completion
6. Download your dataset as JSON, CSV, or Excel

### 💼 Business use cases

#### Price Benchmarking

Know exactly what a used iPhone 13 sells for in Fair vs. Mint condition, by carrier, right now. Set competitive prices when reselling or create fair-value alerts for buyers.

#### Inventory Monitoring

Track when specific models appear on Swappa, filter by condition and carrier, and integrate with your inventory system via Apify webhooks or the API.

#### Market Research

Analyze price trends for refurbished devices across brands and models. Compare Unlocked vs. carrier-locked pricing, or benchmark one generation against another.

#### Price Comparison Tools

Power a used-device price comparison widget or database. Swappa's vetted listings make the data more reliable than unmoderated marketplaces.

### 🔌 Automating Swappa Scraper

Connect Swappa Scraper to your workflow tools:

- **Make (Integromat)**: Schedule daily runs and push results to Google Sheets or Airtable
- **Zapier**: Trigger a Zap when new listings arrive in your dataset
- **Slack**: Post new listings or price drops to a Slack channel automatically
- **Google Sheets**: Export dataset directly to a spreadsheet via Apify integrations
- **REST API**: Call the actor programmatically from any language

### 🌟 Beyond business use cases

#### Research

Study the economics of the circular tech economy. Track how iPhone resale values depreciate by generation. Compare refurbished device pricing to new retail prices.

#### Creative Projects

Build a personal "deal alert" bot that notifies you when a specific phone model drops below your target price on Swappa.

#### Non-profit

Help low-income communities find affordable refurbished devices by monitoring Swappa for the best-value listings in specific conditions.

#### Experimentation

Test price prediction models using historical Swappa data. Build ML models to estimate resale value based on condition, carrier, and storage tier.

### 🤖 Ask an AI assistant about this scraper

You can ask Claude, ChatGPT, or any AI assistant: "How do I use the Swappa Scraper on Apify to find the cheapest unlocked iPhone 13 in Mint condition?" - and get step-by-step instructions.

### ❓ Frequently Asked Questions

#### ❓ Is this legal to use?

Swappa is a public marketplace. Scraping publicly available listing data for research, price comparison, and market analysis is standard practice. Always use data responsibly and in accordance with your local regulations.

#### ❓ How many listings can I get?

Free users: up to 10 listings per run. Paid users: up to 1,000,000 listings per run.

#### ❓ Does it work with all device categories?

Yes - Cell Phones, Laptops, Tablets, Smartwatches, Gaming Consoles, Cameras, Audio, Smart Home, Monitors, and more.

#### ❓ Can I filter by condition?

Yes - filter by Mint, Good, or Fair condition using the `condition` input field.

#### ❓ How often is the data updated?

Every time you run the actor, it pulls live listings from Swappa in real-time. Schedule runs daily or weekly to track price changes.

#### ❓ What format can I download the data in?

JSON, CSV, Excel (.xlsx), and XML - all available directly from the Apify dataset page after your run completes.

#### ❓ Can I search for laptops, tablets, or gaming consoles?

Yes - leave `searchQuery` empty and set `category` to `laptops`, `tablets`, `gaming-consoles`, etc.

#### ❓ Does it include seller ratings?

Yes - `sellerRating` contains the number of feedback ratings the seller has received on Swappa.

#### ❓ What happens if Swappa's layout changes?

The actor is actively maintained by the ParseForge team. If Swappa updates their layout, we update the actor.

#### ❓ Can I run this on a schedule?

Yes - use Apify Schedules to run the actor automatically daily, weekly, or at any cron interval.

#### ❓ Does it capture the seller's location?

Yes - the `location` field contains the city and state the seller ships from (e.g. "Kansas City, MO").

#### ❓ What is the `sellerRating` field?

It's the number of completed transaction ratings on Swappa, not a star score. A seller with 8,546 ratings like "Forlessfones" is highly experienced.

### 🔌 Integrate with any app

- Google Sheets
- Airtable
- Slack
- Microsoft Excel
- Zapier
- Make (formerly Integromat)
- n8n
- Notion
- BigQuery
- Snowflake
- PostgreSQL
- MongoDB
- REST API (any language)
- Python pandas
- R
- Power BI
- Tableau

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Depop Scraper](https://apify.com/parseforge/depop-scraper) | Scrape secondhand fashion listings from Depop |
| [Vinted Scraper](https://apify.com/parseforge/vinted-scraper) | Extract used clothing and accessories from Vinted |
| [Back Market Scraper](https://apify.com/parseforge/backmarket-scraper) | Collect refurbished electronics listings from Back Market |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering dozens of marketplaces, job boards, review sites, and data sources.

***

**Disclaimer:** This actor is an independent tool not affiliated with or endorsed by Swappa. It accesses only publicly available data. Use responsibly and in compliance with applicable laws and Swappa's Terms of Service.

# Actor input Schema

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

Keyword to search for on Swappa (e.g. 'iphone 13', 'macbook pro', 'ps5'). Leave empty to browse a category.

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

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

## `category` (type: `string`):

Filter by Swappa category slug (e.g. 'cell-phones', 'laptops'). Used when searchQuery is empty.

## `condition` (type: `string`):

Filter listings by condition.

## Actor input object example

```json
{
  "searchQuery": "iphone 13",
  "maxItems": 10,
  "category": "cell-phones",
  "condition": ""
}
```

# 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 = {
    "searchQuery": "iphone 13",
    "maxItems": 10
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swappa Scraper | Used Electronics Marketplace",
        "description": "Scrape Swappa listings for used phones, laptops, tablets, and watches with model, condition, carrier, storage, price, seller rating, and photos. Track resale prices and inventory for arbitrage, market research, and competitive intelligence in the used electronics market.",
        "version": "0.1",
        "x-build-id": "KtHQN9NJrIzb4WpQk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~swappa-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-swappa-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~swappa-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-swappa-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~swappa-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-swappa-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for on Swappa (e.g. 'iphone 13', 'macbook pro', 'ps5'). Leave empty to browse a category."
                    },
                    "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"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "cell-phones",
                            "laptops",
                            "tablets",
                            "smartwatches",
                            "gaming-consoles",
                            "cameras",
                            "lenses",
                            "audio",
                            "smart-home",
                            "networking",
                            "storage",
                            "monitors",
                            "desktops",
                            "video-games",
                            "e-readers",
                            "drones",
                            "media-players",
                            "gps-devices"
                        ],
                        "type": "string",
                        "description": "Filter by Swappa category slug (e.g. 'cell-phones', 'laptops'). Used when searchQuery is empty.",
                        "default": "cell-phones"
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "",
                            "mint",
                            "good",
                            "fair"
                        ],
                        "type": "string",
                        "description": "Filter listings by condition.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
