# Slashdot Scraper | Tech News and Comments (`parseforge/slashdot-scraper`) Actor

Scrape tech stories from Slashdot including titles, summaries, departments, authors, comment counts, tags and timestamps. Build datasets of technology news and community discussion for trend analysis, content curation and media research at scale across the full catalog

- **URL**: https://apify.com/parseforge/slashdot-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, 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)

## 📰 Slashdot Scraper

> 🚀 **Export Slashdot tech news stories to CSV, JSON, or Excel in seconds.** No login required. No API key needed.

> 🕒 **Last updated:** 2026-05-22 · **📊 9 fields** per record · **Up to 1,000,000 items** · **11 sections covered**

The Slashdot Scraper extracts tech news stories from Slashdot.org via its live RSS feed. Slashdot has been the internet's premier tech news aggregator since 1997 - covering everything from open source and Linux to AI, hardware, science, and government policy. This actor gives you structured, clean access to that stream of curated tech stories with full metadata.

Each record includes the story title, URL, clean summary text, author, department label, topic category, comment count, publication timestamp, and a topic image URL. The feed is updated in real time as new stories are posted. Coverage spans all 11 major Slashdot sections including Technology, Science, Linux, Games, Hardware, Developers, and Your Rights Online (YRO).

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Researchers | Track tech news trends over time |
| Content teams | Monitor what topics drive community engagement |
| Data scientists | Analyze discourse patterns on tech stories |
| Developers | Build news aggregation apps and dashboards |
| Journalists | Track breaking tech and policy stories |
| Marketers | Identify trending tech topics for content strategy |

### 📋 What the Slashdot Scraper does

- Fetches live stories from any of 11 Slashdot sections via RSS feed
- Extracts clean story summaries with all HTML and share widgets stripped out
- Captures author, topic, department, comment count, and publication date
- Respects maxItems limit to prevent runaway data collection
- Delivers results in seconds - no browser required, no login needed

> 💡 **Why it matters:** Slashdot is one of the internet's oldest and most engaged tech communities. Its editors curate stories for technical depth and community interest, making it a high-signal source for tech sentiment analysis, topic modeling, and trend detection. Comment counts reflect real community engagement that other news aggregators don't surface.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `section` | select | `main` | Slashdot section to scrape |
| `maxItems` | integer | `10` | Max number of stories to return |

**Available sections:** main, tech, science, apple, ask, idle, developers, linux, games, hardware, yro

**Example - Main feed (default):**
```json
{
  "section": "main",
  "maxItems": 10
}
````

**Example - Linux section, 50 stories:**

```json
{
  "section": "linux",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** The Slashdot RSS feed returns approximately 15 stories per request. For most sections, maxItems above 15 will return what is available. The main feed updates continuously as new stories are posted.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Topic icon URL (e.g. `https://a.fsdn.com/sd/topics/ai_64.png`) |
| 📰 `title` | string | Full story headline |
| 🔗 `url` | string | Direct link to the story page |
| 📝 `summary` | string | Clean story summary text (HTML stripped) |
| ✍️ `author` | string | Slashdot editor who posted the story |
| 🏷️ `department` | string | Slashdot's witty department label (e.g. "hide-and-seek") |
| 📂 `topic` | string | Topic category slug (e.g. "ai", "hardware", "internet") |
| 💬 `commentCount` | integer | Number of community comments |
| 🕒 `publishedAt` | string | ISO 8601 publication timestamp |
| 📅 `scrapedAt` | string | ISO 8601 scrape timestamp |
| ❌ `error` | string | Error message if the item failed (null on success) |

**Sample record:**

```json
{
  "imageUrl": "https://a.fsdn.com/sd/topics/ai_64.png",
  "title": "Trump Calls Off AI Executive Order Over Concern It Could Weaken US Tech Edge",
  "url": "https://yro.slashdot.org/story/26/05/21/2034246/trump-calls-off-ai-executive-order-over-concern-it-could-weaken-us-tech-edge",
  "summary": "Trump called off a planned AI executive order just hours before a signing ceremony because he said he was worried the framework could slow America's lead over China. 'We're leading China, we're leading everybody, and I don't want to do anything that's going to get in the way of that lead,' Trump told reporters.",
  "author": "BeauHD",
  "department": "innovation-vs-risk",
  "topic": "ai",
  "commentCount": 38,
  "publishedAt": "2026-05-21T21:00:00.000Z",
  "imageUrl": "https://a.fsdn.com/sd/topics/ai_64.png",
  "scrapedAt": "2026-05-22T03:00:34.000Z",
  "error": null
}
```

**Sample record 2:**

```json
{
  "imageUrl": "https://a.fsdn.com/sd/topics/hardware_64.png",
  "title": "Flipper One Could Be the Ultimate Linux Cyberdeck",
  "url": "https://hardware.slashdot.org/story/26/05/21/194249/flipper-one-could-be-the-ultimate-linux-cyberdeck",
  "summary": "Flipper Devices has finally revealed Flipper One, a Linux-powered cyberdeck that sounds less like a gadget and more like an attempt to rebuild portable ARM computing from the ground up. Unlike Flipper Zero, which focuses on offline protocols like RFID and Sub-1 GHz radio, Flipper One is all about networking, modular hardware, SDR experimentation, local AI, and upstream Linux kernel support.",
  "author": "BeauHD",
  "department": "nerd-bait",
  "topic": "hardware",
  "commentCount": 26,
  "publishedAt": "2026-05-21T20:00:00.000Z",
  "scrapedAt": "2026-05-22T03:00:34.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🌐 No login required | Works entirely on public RSS feed |
| ⚡ Fast execution | Typical run completes in under 5 seconds |
| 🧹 Clean summaries | HTML tags, share buttons, iframes stripped automatically |
| 📂 11 sections | Main, Tech, Science, Linux, Games, Hardware, YRO, and more |
| 🖼️ Topic images | Icon URLs for every story topic category |
| 🕒 Real-time data | Always fetches live feed - no cached results |
| 📦 Export-ready | CSV, JSON, Excel, XML download in one click |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual RSS scraping | Web scraping |
|---|---|---|---|
| Clean text output | ✅ Automatic | ❌ Manual cleanup | ❌ Complex parsing |
| All sections | ✅ 11 sections | Partial | Partial |
| Comment counts | ✅ Yes | ✅ Yes | Requires JS |
| Author info | ✅ Yes | ✅ Yes | Sometimes |
| Cloud execution | ✅ Yes | ❌ Local only | ❌ Local only |
| Scheduled runs | ✅ Via Apify | ❌ No | ❌ No |

### 🚀 How to use

1. [Create a free Apify account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the Slashdot Scraper actor page
3. Choose a section (or leave as "main" for all stories)
4. Set maxItems (10 for preview, up to 1,000,000 for paid plans)
5. Click "Start" and download results as CSV, JSON, or Excel

### 💼 Business use cases

#### Media Monitoring

Track which tech stories gain the most community engagement on Slashdot. The `commentCount` field acts as a proxy for controversy and community interest. Stories with 100+ comments on Slashdot often represent inflection points in tech discourse - useful for PR teams and communications professionals.

#### Competitive Intelligence

Monitor the Hardware and Developers sections to track what new products, frameworks, and technologies the tech community is discussing. Use the `department` and `topic` fields to filter by relevance to your industry.

#### Academic Research

Slashdot has a documented, consistent editorial style dating back to 1997. Researchers studying online tech communities, political economy of technology, or media framing of tech issues can use this actor to build longitudinal datasets. The `section` and `topic` fields support topic modeling and classification tasks.

#### Content Strategy

Identify trending topics across tech, science, and policy before they hit mainstream media. Slashdot's audience of technical early adopters often surfaces niche stories 24-48 hours ahead of mainstream coverage. Use the `publishedAt` field to track story timing relative to other publications.

### 🔌 Automating Slashdot Scraper

Connect this actor to automation tools to build real-time tech news workflows:

- **Make.com** - Trigger on new Slashdot stories, send to Slack, email, or CRM
- **Zapier** - Auto-post new stories to social media or internal tools
- **Slack** - Pipe breaking tech news directly to your team channel
- **Google Sheets** - Append new stories to a shared tracking spreadsheet
- **Webhooks** - Send story data to any custom endpoint on each run

### 🌟 Beyond business use cases

#### Research

Study how the Slashdot community frames AI, open source, and government policy stories. The `summary` field gives you curated, editor-selected text - a consistent signal that's easier to analyze than raw web scraping.

#### Creative projects

Build a personal tech digest app, a browser extension showing Slashdot story comment counts, or a Discord bot that posts breaking Linux and hardware stories.

#### Non-profit and advocacy

YRO (Your Rights Online) section covers digital rights, surveillance, and internet freedom - useful for organizations tracking tech policy and civil liberties developments.

#### Experimentation

Use Slashdot as a training ground for NLP experiments: topic classification with `topic` labels, sentiment analysis on `summary` text, or comment volume prediction.

### 🤖 Ask an AI assistant about this scraper

You can ask: "How do I use the Slashdot Scraper to monitor AI news stories daily?" or "What fields does the Slashdot Scraper return?" and get instant help from Apify's AI assistant.

### ❓ Frequently Asked Questions

**❓ Does this require a Slashdot account?**
No. This actor uses the public RSS feed - no account or login required.

**❓ How many stories are available per run?**
The RSS feed returns approximately 15 stories per section. Setting maxItems above 15 will return what is available in the current feed.

**❓ How often does Slashdot update?**
Slashdot typically posts 10-20 stories per day on the main feed. Individual section feeds update less frequently.

**❓ Can I monitor a section continuously?**
Yes. Use Apify's built-in scheduler to run the actor on an interval - hourly, daily, or weekly.

**❓ What does the "department" field contain?**
Each Slashdot story has a witty department label set by the editor (e.g., "nerd-bait", "innovation-vs-risk", "hide-and-seek"). It's a Slashdot tradition since the early days.

**❓ What is the imageUrl field?**
Each Slashdot topic has an associated 64px icon image hosted at `a.fsdn.com`. For example, an "ai" topic gives you `https://a.fsdn.com/sd/topics/ai_64.png`. This is the topic category icon, not a story-specific image.

**❓ What topics does Slashdot cover?**
Common topics include: ai, internet, hardware, science, government, linux, music, usa, and many more. The `topic` field contains the raw slug from the feed.

**❓ Is the summary the full story text?**
No. The summary is Slashdot's curated excerpt - typically 2-5 paragraphs. The full source article is linked via the `url` field.

**❓ What sections are available?**
main, tech, science, apple, ask, idle, developers, linux, games, hardware, yro

**❓ Can I use this for free?**
Free users get up to 10 stories per run. Paid plans unlock up to 1,000,000 items. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

**❓ What export formats are supported?**
CSV, JSON, Excel (XLSX), and XML are all available from the Apify dataset viewer.

**❓ Is the data from cache or live?**
Always live. Each run fetches the current RSS feed in real time - no cached responses.

### 🔌 Integrate with any app

Export Slashdot data directly to:

- **Google Sheets** via Apify's Google Sheets integration
- **Airtable** via webhook or Zapier
- **Notion** via Make.com automation
- **Slack** via webhook trigger
- **BigQuery** via Apify's dataset export
- **AWS S3** via Apify storage integrations
- **REST APIs** via Apify webhooks on actor run completion
- **Excel** via direct XLSX download from dataset
- **MongoDB** via custom webhook and Node.js integration
- **Power BI** via CSV/Excel dataset export

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Hacker News Scraper](https://apify.com/parseforge/hacker-news-scraper) | Scrape HN stories, comments, and Ask HN posts |
| [BoardGameGeek Scraper](https://apify.com/parseforge/boardgamegeek-scraper) | Top-ranked board games and ratings |
| [Chess.com Scraper](https://apify.com/parseforge/chess-com-scraper) | Player profiles, ratings, and game history |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for hundreds of websites.

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

> **⚠️ Disclaimer:** Independent tool, not affiliated with Slashdot or its parent company. Only publicly available RSS feed data from Slashdot.org is collected. Use responsibly and in accordance with Slashdot's Terms of Service.

# Actor input Schema

## `section` (type: `string`):

Slashdot section to scrape stories from.

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

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

## Actor input object example

```json
{
  "section": "main",
  "maxItems": 10
}
```

# 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
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/slashdot-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 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/slashdot-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
}' |
apify call parseforge/slashdot-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Slashdot Scraper | Tech News and Comments",
        "description": "Scrape tech stories from Slashdot including titles, summaries, departments, authors, comment counts, tags and timestamps. Build datasets of technology news and community discussion for trend analysis, content curation and media research at scale across the full catalog",
        "version": "0.1",
        "x-build-id": "K73DKo7CWaqMvwgPf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~slashdot-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-slashdot-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~slashdot-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-slashdot-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~slashdot-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-slashdot-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": {
                    "section": {
                        "title": "Section",
                        "enum": [
                            "main",
                            "tech",
                            "science",
                            "apple",
                            "ask",
                            "idle",
                            "developers",
                            "linux",
                            "games",
                            "hardware",
                            "yro"
                        ],
                        "type": "string",
                        "description": "Slashdot section to scrape stories from.",
                        "default": "main"
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
