# Warframe Market Prices Scraper (`parseforge/warframe-market-prices-scraper`) Actor

Track live platinum prices on Warframe.market for any tradable item. Pull item name, tags, ducats, mod ranks, plus the lowest sell and highest buy across active orders with seller counts. Handy for flipping prime parts, pricing mods, or watching the trade economy.

- **URL**: https://apify.com/parseforge/warframe-market-prices-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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)

## 🎮 Warframe Market Prices Scraper

> 🚀 **Export live Warframe.market platinum prices in seconds.** Pull any tradable item with its lowest sell and highest buy across active orders.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 21 fields** per record · official Warframe.market API · live order prices

Turn Warframe.market into clean, structured records you can drop into a trading spreadsheet, a price tracker, or a Discord flipping bot. Give the Actor a list of item slugs (or let it pull from the full catalog) and get each item's name, tags, ducats, and mod ranks, plus a live price summary built from active buy and sell orders.

Coverage is the public Warframe.market catalog and live order book as the official v2 API publishes it: every tradable item with its English name, tags, ducat value, mod ranks, and trading tax, enriched with the lowest sell price, highest buy price, and order counts from currently active orders. Data is read live, so every run reflects the market at run time.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Traders and prime-part flippers | Find the best sell and buy prices fast |
| Discord and Telegram bot builders | Power a `!price` lookup command |
| Price-tracker and tool makers | Snapshot the market on a schedule |
| Players pricing their inventory | Check what an item is worth right now |

### 📋 What the Warframe Market Prices Scraper does

This Actor calls the official Warframe.market v2 API and returns one clean record per item:

- **Item slugs** — pass a list of slugs (the last path segment of any item URL), or leave empty to take the first items from the full catalog.
- **Live order prices** — fetch active buy and sell orders and add a price summary (lowest sell, highest buy, order counts). Turn off for catalog data only, which is much faster.
- **Online sellers only** — when pulling prices, count only orders from users who are online or in game, so the summary reflects prices you can actually trade right now.

You control how many items come back, and every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `items` | array | Warframe.market item slugs to fetch, for example `mirage_prime_blueprint` or `creeping_bullseye`. Find a slug in any item URL (the last path segment). Leave empty to take the first items from the full catalog. |
| `includeOrders` | boolean | Fetch live buy and sell orders for each item and add a price summary (lowest sell, highest buy, order counts). Turn off to return catalog item data only. Defaults to `true`. |
| `onlineOnly` | boolean | When pulling order prices, only count orders from users currently online or in game. Defaults to `true`. |
| `maxItems` | integer | How many items to return. Free plan is capped at 10. |

**Example 1 — price specific items, online sellers only**
```json
{
    "items": ["mirage_prime_blueprint", "creeping_bullseye", "secura_dual_cestra"],
    "includeOrders": true,
    "onlineOnly": true,
    "maxItems": 10
}
````

**Example 2 — catalog data only, no order prices**

```json
{
    "items": [],
    "includeOrders": false,
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** prices are in platinum (p). With `onlineOnly` on, the summary reflects only sellers and buyers who are reachable right now, which is the most realistic picture for trading. Turn `includeOrders` off when you only need catalog metadata and want a much faster run.

### 📊 Output

Each record looks like this:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Item icon |
| 📌 `name` | Item name (English) |
| 🏷 `slug` | Warframe.market item slug |
| 🆔 `id` | Internal item ID |
| 🗂 `tags` | Array of item tags |
| 🪙 `ducats` | Ducat value |
| 🔢 `maxRank` | Maximum mod rank (mods only) |
| 🎖 `reqMasteryRank` | Required mastery rank |
| 💸 `tradingTax` | Credit trading tax |
| 🧩 `setRoot` | Whether this item is the root of a set |
| 📖 `wikiLink` | Link to the wiki page |
| 📝 `description` | Item description |
| 💸 `minSellPrice` | Lowest sell price in platinum |
| 💰 `maxBuyPrice` | Highest buy price in platinum |
| 📉 `sellOrderCount` | Number of counted sell orders |
| 📈 `buyOrderCount` | Number of counted buy orders |
| 🔢 `totalOrderCount` | Total counted orders |
| 🔗 `itemUrl` | Link to the item on warframe.market |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — a prime part with live prices**

```json
{
    "imageUrl": "https://warframe.market/static/assets/items/images/en/mirage_prime_blueprint.png",
    "name": "Mirage Prime Blueprint",
    "slug": "mirage_prime_blueprint",
    "id": "5a2feeb1c2c9e90cbdaa61b3",
    "tags": ["blueprint", "prime", "warframe", "mirage"],
    "ducats": 15,
    "maxRank": null,
    "reqMasteryRank": null,
    "tradingTax": 2000,
    "setRoot": false,
    "wikiLink": "https://warframe.fandom.com/wiki/Mirage/Prime",
    "description": "The blueprint for the Mirage Prime Warframe.",
    "minSellPrice": 18,
    "maxBuyPrice": 12,
    "sellOrderCount": 34,
    "buyOrderCount": 9,
    "totalOrderCount": 43,
    "itemUrl": "https://warframe.market/items/mirage_prime_blueprint",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

**Real sample — a mod with ranks**

```json
{
    "imageUrl": "https://warframe.market/static/assets/items/images/en/creeping_bullseye.png",
    "name": "Creeping Bullseye",
    "slug": "creeping_bullseye",
    "id": "54e644ffe779897594fa68d2",
    "tags": ["mod", "pistol", "rare"],
    "ducats": null,
    "maxRank": 5,
    "reqMasteryRank": null,
    "tradingTax": 6000,
    "setRoot": null,
    "wikiLink": "https://warframe.fandom.com/wiki/Creeping_Bullseye",
    "description": "A pistol mod that trades fire rate for critical chance.",
    "minSellPrice": 10,
    "maxBuyPrice": 5,
    "sellOrderCount": 21,
    "buyOrderCount": 4,
    "totalOrderCount": 25,
    "itemUrl": "https://warframe.market/items/creeping_bullseye",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Reads the official Warframe.market v2 API, not a scraped HTML page.
- A ready-made price summary: lowest sell, highest buy, and order counts.
- Online-only filtering so prices reflect what you can actually trade now.
- Works on a hand-picked slug list or the full catalog.
- No account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Price summary | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Checking each item page by hand | Hours | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | Manual | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Warframe Market Prices Scraper.
3. Add the item slugs you want (or leave `items` empty for the catalog).
4. Keep `includeOrders` on for live prices, then set `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Trading and flipping

| Goal | How this helps |
|---|---|
| Find arbitrage on prime parts | Compare `minSellPrice` and `maxBuyPrice` |
| Price a batch of items | Pass a slug list and read the summaries |

#### Bots and tools

| Goal | How this helps |
|---|---|
| Power a price-lookup bot | Feed it name, slug, and price fields |
| Build a watchlist tracker | Re-run on a schedule for your slugs |

#### Market analytics

| Goal | How this helps |
|---|---|
| Track the trade economy | Snapshot prices over time |
| Study supply and demand | Compare sell and buy order counts |

#### Inventory pricing

| Goal | How this helps |
|---|---|
| Value your stock | Look up each item's live prices |
| Decide what to sell | Sort by spread between buy and sell |

### 🔌 Automating Warframe Market Prices Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route prices into sheets or databases.
- **Slack** or **Discord** to post price alerts when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how a player-driven trade economy behaves.
- **Personal:** build your own price cheat sheet.
- **Non-profit:** power a community trading resource.
- **Experimentation:** prototype a game-market app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to rank items by profit margin, spot underpriced sells, or build a flipping shortlist.

### ❓ Frequently Asked Questions

**Do I need a Warframe account or API key?**
No. The Actor reads the public Warframe.market v2 API, which needs no login or key.

**Where do I find an item slug?**
It is the last path segment of any item URL on warframe.market, for example `mirage_prime_blueprint`.

**What does "online sellers only" do?**
With `onlineOnly` on, the price summary counts only orders from users currently online or in game, so it reflects prices you can trade right now.

**What currency are prices in?**
Platinum (p), the in-game tradable currency.

**Can I skip order prices for speed?**
Yes. Turn `includeOrders` off to return catalog item data only, which is much faster.

**Why are ducats or mod ranks sometimes null?**
Ducats apply to prime parts and `maxRank` applies to mods. The Actor passes through whatever the source provides for each item type.

**What if a slug does not exist?**
The Actor records an error row for that slug and continues with the rest.

**How fresh is the data?**
Every run reads live from Warframe.market, so it reflects the market at run time.

**Can I export to Excel or CSV?**
Yes. Apify lets you download the dataset as CSV, Excel, JSON, or XML.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot prices on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Brawlify Brawl Stars Database Scraper](https://apify.com/parseforge)
- [UEX Star Citizen Commodities Scraper](https://apify.com/parseforge)
- More game and market data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

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

> **⚠️ Disclaimer:** independent tool, not affiliated with Warframe.market, Digital Extremes, or Warframe. Only publicly available data is collected.

# Actor input Schema

## `items` (type: `array`):

Warframe.market item slugs to fetch, for example 'mirage\_prime\_blueprint' or 'creeping\_bullseye'. Find a slug in any item URL on warframe.market (the last path segment). Leave empty to take the first items from the full catalog.

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

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

## `includeOrders` (type: `boolean`):

Fetch live buy and sell orders for each item and add a price summary (lowest sell, highest buy, order counts). Turn off to return catalog item data only, which is much faster.

## `onlineOnly` (type: `boolean`):

When pulling order prices, only count orders from users who are currently online or in game. This better reflects prices you can actually trade right now.

## Actor input object example

```json
{
  "items": [
    "mirage_prime_blueprint",
    "creeping_bullseye",
    "secura_dual_cestra"
  ],
  "maxItems": 10,
  "includeOrders": true,
  "onlineOnly": true
}
```

# 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 = {
    "items": [
        "mirage_prime_blueprint",
        "creeping_bullseye",
        "secura_dual_cestra"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/warframe-market-prices-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 = {
    "items": [
        "mirage_prime_blueprint",
        "creeping_bullseye",
        "secura_dual_cestra",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/warframe-market-prices-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 '{
  "items": [
    "mirage_prime_blueprint",
    "creeping_bullseye",
    "secura_dual_cestra"
  ],
  "maxItems": 10
}' |
apify call parseforge/warframe-market-prices-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Warframe Market Prices Scraper",
        "description": "Track live platinum prices on Warframe.market for any tradable item. Pull item name, tags, ducats, mod ranks, plus the lowest sell and highest buy across active orders with seller counts. Handy for flipping prime parts, pricing mods, or watching the trade economy.",
        "version": "0.1",
        "x-build-id": "R7SG1rqER02aQ0KPL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~warframe-market-prices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-warframe-market-prices-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~warframe-market-prices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-warframe-market-prices-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~warframe-market-prices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-warframe-market-prices-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": {
                    "items": {
                        "title": "Item slugs",
                        "type": "array",
                        "description": "Warframe.market item slugs to fetch, for example 'mirage_prime_blueprint' or 'creeping_bullseye'. Find a slug in any item URL on warframe.market (the last path segment). Leave empty to take the first items from the full catalog.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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"
                    },
                    "includeOrders": {
                        "title": "Include live order prices",
                        "type": "boolean",
                        "description": "Fetch live buy and sell orders for each item and add a price summary (lowest sell, highest buy, order counts). Turn off to return catalog item data only, which is much faster.",
                        "default": true
                    },
                    "onlineOnly": {
                        "title": "Online sellers only",
                        "type": "boolean",
                        "description": "When pulling order prices, only count orders from users who are currently online or in game. This better reflects prices you can actually trade right now.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
