# devRant Scraper | Developer Community Posts (`parseforge/devrant-scraper`) Actor

Scrape posts from devRant including rant text, tags, upvotes, comment counts, authors and timestamps. Build datasets of developer community sentiment and humor for trend analysis, content research and natural language processing projects at scale across the full catalog

- **URL**: https://apify.com/parseforge/devrant-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Social media, Developer tools, Other
- **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)

## 😤 DevRant Scraper

> 🚀 **Export developer rants, scores, and tags from DevRant in seconds.** No login required, no API key needed - just point, click, and download.

> 🕒 **Last updated:** 2026-05-22 · **📊 10 fields** per record · **Thousands of rants** · **Global developer community**

The DevRant Scraper pulls developer rants directly from DevRant's public API. DevRant is a community where developers vent their frustrations, share wins, and discuss the everyday chaos of software development. This actor exports structured data including rant content, scores, comment counts, author info, tags, post timestamps, and attached images - ready for CSV, Excel, JSON, or XML download.

DevRant hosts hundreds of thousands of rants from developers worldwide. The API provides three feed modes: algo (community-curated), recent (chronological), and top (highest scored over a time range). All data is public and requires no authentication.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Researchers | Study developer sentiment, frustrations, and community trends |
| Data Scientists | Build NLP models on developer-written text |
| HR/Recruiters | Understand what frustrates developers in real workplaces |
| Product Managers | Discover pain points in popular tools and frameworks |
| Journalists | Source developer opinion for tech articles |
| Community Managers | Monitor discussions around specific technologies via tags |

### 📋 What the DevRant Scraper does

- Fetches rants from the DevRant public API with no authentication required
- Supports three sort modes: algo (recommended feed), recent (newest first), top (highest scored)
- For top rants, filters by time range: today, this week, this month, or all time
- Automatically paginates through the feed to reach your desired item count
- Extracts all 10 fields per rant: ID, content, score, comment count, author, author score, tags, post time, image URL, and scrape timestamp
- Free users get a 10-item preview; paid users can extract up to 1,000,000 rants

> 💡 **Why it matters:** DevRant captures authentic developer voice - unfiltered opinions on tools, languages, workplaces, and practices. This dataset is uniquely valuable for sentiment analysis, developer experience research, and understanding real-world pain points in software engineering.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | integer | 10 | Maximum number of rants to collect (free: 10, paid: up to 1,000,000) |
| `sort` | select | algo | Feed sort mode: algo, recent, or top |
| `range` | select | day | Time range for top sort: day, week, month, or all |

**Example 1 - Algo feed (default):**
```json
{
  "sort": "algo",
  "maxItems": 100
}
````

**Example 2 - Top rants of the week:**

```json
{
  "sort": "top",
  "range": "week",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** The `range` field only has effect when `sort` is set to `top`. For `algo` and `recent` sort modes, the range setting is ignored. Free users are limited to 10 rants regardless of `maxItems`.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | null | URL of attached image, or null if no image |
| 🔢 `rantId` | number | Unique DevRant rant identifier |
| 📝 `content` | string | Full rant text content |
| ⭐ `score` | number | Community upvote score |
| 💬 `commentCount` | number | Number of comments on the rant |
| 👤 `author` | string | Username of the rant author |
| 🏆 `authorScore` | number | Total community score of the author |
| 🏷️ `tags` | array | List of tags attached to the rant |
| 📅 `postedAt` | string | ISO 8601 timestamp when the rant was posted |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp when data was collected |

**Sample records (from real run on 2026-05-21):**

```json
[
  {
    "imageUrl": null,
    "rantId": 19418245,
    "content": ":grumble:\n\nGuys,... as you may know: don't start studying for certificates for skills just because a job application lists them... because in the end, there's just HR on the other end and they don't care about if you are certing it up, they just care you have experience. Sad but true.\n\nJust study for yourself... lol",
    "score": 1,
    "commentCount": 10,
    "author": "CaptainRant",
    "authorScore": 4836,
    "tags": ["rant", "job-hunting", "studying", "skills"],
    "postedAt": "2026-05-18T15:18:48.000Z",
    "scrapedAt": "2026-05-22T02:56:24.388Z"
  },
  {
    "imageUrl": null,
    "rantId": 19418358,
    "content": "As if the tech stack weren't enough, now they also have personality requirements too. LOL.",
    "score": 1,
    "commentCount": 4,
    "author": "CaptainRant",
    "authorScore": 4836,
    "tags": ["rant", "requirements", "job-hunting", "personality"],
    "postedAt": "2026-05-19T09:30:18.000Z",
    "scrapedAt": "2026-05-22T02:56:24.388Z"
  }
]
```

### ✨ Why choose this Actor

- **No login required** - uses DevRant's fully public API
- **10 fields per rant** - content, scores, author details, tags, timestamps, and images
- **Three feed modes** - algo, recent, and top with time ranges
- **Bun.sh runtime** - ultra-fast execution, sub-second API calls
- **Free 10-item preview** - test output structure before committing to a paid plan
- **Pay-per-result pricing** - only pay for the data you actually receive
- **Structured tags** - each rant's tag array is pre-parsed for immediate filtering

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | DevRant API directly |
|---|---|---|---|
| No coding needed | ✅ | ❌ | ❌ |
| Pagination handled | ✅ | Manual | Manual |
| CSV/Excel export | ✅ | ❌ | ❌ |
| Free preview | ✅ (10 items) | ✅ | ✅ |
| Structured output | ✅ | Manual | Raw JSON |
| Zapier/Make integration | ✅ | ❌ | ❌ |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the **DevRant Scraper** actor page
3. Choose your sort mode (`algo`, `recent`, or `top`)
4. Set `maxItems` to your desired count (free users get 10 items preview)
5. Click **Start** and wait a few seconds
6. Download your dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Developer Sentiment Analysis

Track how developers feel about specific technologies by filtering rants with relevant tags. Identify rising frustrations with frameworks, languages, or tools before they become mainstream news. Use the score and comment count to weight sentiment by community engagement.

#### NLP Training Data

DevRant contains authentic, unedited developer writing - ideal training data for code-adjacent NLP models. The structured tags provide natural labels for topic classification. Thousands of rants with varied vocabulary, slang, and technical terminology.

#### Tech Trend Research

Monitor which technologies appear most frequently in rants over time. Rising mentions of a tool often precede broader industry discussion. The `postedAt` timestamp enables time-series analysis of community attention.

#### Developer Experience (DevEx) Research

HR teams and DevEx researchers use DevRant data to understand real pain points - not survey responses, but raw unfiltered frustrations. Correlate tag clusters to identify systemic issues in specific domains like code review, deployment, or onboarding.

### 🔌 Automating DevRant Scraper

Connect this actor to 1,000+ apps via Apify integrations:

- **Make (formerly Integromat)** - trigger runs on a schedule, send results to Google Sheets or Airtable
- **Zapier** - pipe new rants into Slack channels, Notion databases, or email digests
- **Apify Scheduler** - run daily or weekly to build a longitudinal rant dataset
- **Webhooks** - get notified when a run completes and data is ready
- **Apify API** - programmatic access for custom data pipelines

### 🌟 Beyond business use cases

#### Academic Research

Computational social scientists can study how developer communities express frustration, build solidarity, and create shared identity through humor and complaint. DevRant's tag system enables targeted corpus construction.

#### Creative Writing & Satire

Writers covering the tech industry can mine authentic developer voice for dialogue inspiration, satire material, or cultural color. The community's distinctive blend of dark humor and technical precision is well-represented.

#### Non-Profit and Advocacy

Organizations working on developer mental health, workplace culture improvement, or tech industry reform can use rant data to document real experiences without conducting expensive surveys.

#### Experimentation

Data hobbyists can build dashboards tracking real-time developer mood, create tag co-occurrence networks, or train text classifiers to detect complaint types - all with freely available, continuously updated data.

### 🤖 Ask an AI assistant about this scraper

Have questions about this actor? Ask an AI assistant:

*"I'm looking at the ParseForge DevRant Scraper on Apify. It scrapes developer rant data from devrant.com. Can you help me understand what I can do with rant scores, tags, and author data for sentiment analysis?"*

### ❓ Frequently Asked Questions

#### ❓ Does this require a DevRant account or API key?

No. DevRant's API is fully public. No account, login, or API key is required to use this scraper.

#### ❓ What is the algo sort mode?

Algo is DevRant's community-curated feed - a mix of recent and popular rants selected by their algorithm. It is the recommended starting point for general data collection.

#### ❓ How many rants can I collect?

Free users are limited to 10 rants (preview). Paid users can collect up to 1,000,000 rants per run.

#### ❓ What does the score field mean?

Score is the net upvote count on a rant. Higher scores indicate the community resonated strongly with the rant.

#### ❓ When does imageUrl have a value?

Some DevRant posts include attached images (screenshots of code, memes, etc.). When an image is attached, `imageUrl` contains the direct URL. Most rants are text-only, so `imageUrl` is `null` for those.

#### ❓ How fresh is the data?

Data is fetched in real-time from DevRant's API when you run the actor. There is no caching - every run fetches live data.

#### ❓ What does authorScore mean?

AuthorScore is the author's total community reputation score on DevRant - the sum of all upvotes they have received across all their posts and comments.

#### ❓ Can I filter by tag?

The actor fetches rants from the chosen feed. Post-processing by tag is best done in your own data pipeline or in Apify's dataset filters. The `tags` field on every item makes this straightforward.

#### ❓ How does the range field work with top sort?

When `sort` is `top`, the `range` field selects the time window: `day` (today's top rants), `week`, `month`, or `all` (all-time top rants). Range is ignored when sort is `algo` or `recent`.

#### ❓ Is this actor maintained?

Yes. ParseForge actively maintains all actors in the collection. If DevRant changes their API, the actor will be updated.

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

Yes. Use Apify Scheduler to run the actor daily, weekly, or on any cron schedule to build a longitudinal dataset of developer rants over time.

#### ❓ What output formats are available?

The Apify platform exports datasets as CSV, Excel (XLSX), JSON, JSONL, XML, or RSS. No additional configuration needed.

### 🔌 Integrate with any app

Connect DevRant Scraper to your favorite tools directly from the Apify Console:

**Productivity & Databases:** Google Sheets, Airtable, Notion, Monday.com, Coda

**Automation:** Make (Integromat), Zapier, n8n, Pipedream

**Data & Analytics:** BigQuery, Snowflake, MongoDB, PostgreSQL, Elasticsearch

**Communication:** Slack, Microsoft Teams, Discord webhooks

**Storage:** Amazon S3, Google Drive, Dropbox

**BI Tools:** Tableau, Power BI, Looker, Metabase

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [ParseForge / Jobrapido Scraper](https://apify.com/parseforge/jobrapido-scraper) | Export job listings from Jobrapido across 50+ country sites |
| [ParseForge / CarsDB Scraper](https://apify.com/parseforge/carsdb-scraper) | Scrape used and new car listings from Myanmar's largest auto marketplace |
| [ParseForge / Bandcamp Scraper](https://apify.com/parseforge/bandcamp-scraper) | Export music, albums, and artist data from Bandcamp |

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

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

> **⚠️ Disclaimer:** Independent tool, not affiliated with DevRant. Only publicly available data collected. This actor uses DevRant's public API; use of collected data is subject to DevRant's terms of service. Always review and comply with applicable terms of service and data protection regulations before using scraped data commercially.

# Actor input Schema

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

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

## `sort` (type: `string`):

Sort mode for rants. 'top' requires a range to be set.

## `range` (type: `string`):

Time range when sort=top. Ignored for algo and recent.

## Actor input object example

```json
{
  "maxItems": 10,
  "sort": "algo",
  "range": "day"
}
```

# 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 = {
    "maxItems": 10,
    "sort": "algo",
    "range": "day"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "devRant Scraper | Developer Community Posts",
        "description": "Scrape posts from devRant including rant text, tags, upvotes, comment counts, authors and timestamps. Build datasets of developer community sentiment and humor for trend analysis, content research and natural language processing projects at scale across the full catalog",
        "version": "0.1",
        "x-build-id": "pXUPWA2YtLFLaw0jH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~devrant-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-devrant-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~devrant-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-devrant-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~devrant-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-devrant-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": {
                    "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"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "algo",
                            "recent",
                            "top"
                        ],
                        "type": "string",
                        "description": "Sort mode for rants. 'top' requires a range to be set.",
                        "default": "algo"
                    },
                    "range": {
                        "title": "Range (for Top sort only)",
                        "enum": [
                            "day",
                            "week",
                            "month",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time range when sort=top. Ignored for algo and recent.",
                        "default": "day"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
