# RSS Feed Reader – Parse RSS, Atom & Podcast Feeds to JSON (`haketa/rss-feed-reader`) Actor

Read any RSS, Atom, RDF or podcast feed and get clean, structured items: title, link, author, date, full content, categories, media/enclosure and podcast duration. Auto-discovers the feed from a website URL. Filter by keyword or date. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/haketa/rss-feed-reader.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Developer tools, News, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<h1 align="center">RSS Feed Reader 📰</h1>

<p align="center">
  <img alt="Platform" src="https://img.shields.io/badge/Made%20for-Apify-97D700?style=for-the-badge">
  <img alt="Formats" src="https://img.shields.io/badge/RSS%20%C2%B7%20Atom%20%C2%B7%20RDF%20%C2%B7%20Podcast-4C8BF5?style=for-the-badge">
  <img alt="Auto" src="https://img.shields.io/badge/Feed-Auto--discovery-8A2BE2?style=for-the-badge">
  <img alt="No code" src="https://img.shields.io/badge/No%20code-required-FF7A00?style=for-the-badge">
  <img alt="Export" src="https://img.shields.io/badge/Export-Excel%20%7C%20CSV%20%7C%20JSON%20%7C%20API-00B3A4?style=for-the-badge">
</p>

<p align="center"><b>Turn any RSS, Atom or podcast feed into clean, structured data.</b></p>

Give it a feed URL — or just a **website URL** and it finds the feed for you — and get back every item as a tidy record: **title, link, author, publish date, full content, categories, media and podcast duration**. Works with **RSS 2.0, Atom, RSS 1.0 (RDF) and podcast feeds**, and lets you **filter by keyword or date**.

Perfect for **news monitoring, content aggregation, AI/RAG pipelines, podcast tracking** and automation — no code required.

---

### ⚡ At a glance

| | |
|---|---|
| 📡 **Every format** | RSS 2.0, Atom, RDF and podcast feeds |
| 🔎 **Auto-discovery** | Paste a website URL — the feed is found automatically |
| 📄 **Full content** | Title, summary and full article/episode text (clean) |
| 🎧 **Podcast-ready** | Audio/video enclosure URL, type and duration |
| 🔍 **Filters** | Keyword and "since date" filtering |
| 📦 **Bulk** | Read one feed or thousands from a list |
| ⚡ **Fast & cheap** | Pure-HTTP — no browser |
| 💾 **Export** | Excel, CSV, JSON, HTML or API |

---

### 📌 Why this Actor?

Feeds come in many flavors and are messy to parse. This Actor normalizes them all into one clean schema:

- 📡 **Any feed format** — RSS, Atom, RDF and podcast (iTunes) feeds, including CDATA, namespaces and malformed markup.
- 🔎 **Feed auto-discovery** — don't know the feed URL? Paste the site's homepage and the Actor locates the `<link rel="alternate">` feed for you.
- 📄 **Clean content** — HTML stripped to readable plain text, with an option to keep the raw HTML.
- 🎧 **Podcast metadata** — enclosure (MP3/MP4) URL, media type, and episode duration in seconds.
- 🔍 **Built-in filters** — keyword and since-date so you only pull what you need.
- 📦 **Bulk-friendly** — feed a big list of feeds and get one merged, structured dataset.

---

### ✨ What you get (data fields)

> One row per feed item (article / episode), with its source feed attached.

#### 📰 Item

| Field | Description |
|-------|-------------|
| `title` | Item title |
| `link` | Item URL |
| `author` | Author / creator |
| `publishedAt` | Publish date (ISO 8601) |
| `summary` | Short summary (plain text) |
| `content` | Full content (plain text) |
| `contentHtml` | Raw HTML content *(optional)* |
| `categories` | Categories / tags |
| `guid` | Unique item identifier |
| `commentsUrl` | Comments page URL |

#### 🎧 Media &amp; podcast

| Field | Description |
|-------|-------------|
| `isPodcast` | Whether the item has audio/video media |
| `mediaUrl` | Enclosure / media URL (audio, video, image) |
| `mediaType` | Media MIME type (e.g. `audio/mpeg`) |
| `mediaLength` | Media size in bytes |
| `durationSeconds` | Podcast episode duration |
| `image` | Item image URL |

#### 📡 Feed context

| Field | Description |
|-------|-------------|
| `feedTitle` | Source feed title |
| `feedLink` | Feed website link |
| `feedDescription` | Feed description |
| `feedLanguage` | Feed language |
| `feedUrl` | Source feed URL |

---

### 🚀 Quick start

1. Click **Try for free / Start**.
2. Add your **Feed URLs** — one per line (feed or website URL):
````

https://feeds.bbci.co.uk/news/rss.xml
https://www.theverge.com
https://feeds.megaphone.fm/vergecast

````
3. *(Optional)* Set **Max items per feed**, a **Keyword**, or a **Since date**.
4. Click **Save &amp; Start**, then export from the **Dataset** tab.

> 💡 **Tip:** Don't have the feed URL? Just paste the website — the Actor discovers the feed automatically.

---

### 🎯 Use cases

| Use case | What it delivers |
|----------|------------------|
| 📰 **News & brand monitoring** | Track publishers or a keyword across many feeds in one dataset. |
| 🤖 **AI / RAG pipelines** | Feed clean article text straight into LLMs, embeddings or a vector DB. |
| 🎧 **Podcast tracking** | Collect episodes with audio URLs and durations for analysis or downloads. |
| 🧲 **Content aggregation** | Build a unified feed for a newsletter, dashboard or Slack digest. |
| 🕵️ **Competitor content** | Watch competitors' blogs and see what they publish, when. |
| 🔁 **Automation** | Trigger Make / Zapier flows on new items via the API. |

---

### ⚙️ Input reference

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| **Feed URLs** | list | *sample* | Feed or website URLs, one per line. |
| **Feed URLs from file / list** | list | — | Bulk-load feeds from a file, URL or Google Sheet. |
| **Max items per feed** | number | `0` | Cap per feed. `0` = all. |
| **Keyword filter** | string | — | Only items whose title/content contains this text. |
| **Only items since (date)** | string | — | Only items on/after this date (e.g. `2026-07-01`). |
| **Include full content** | boolean | `true` | Add full plain-text content. |
| **Include raw HTML content** | boolean | `false` | Also keep the original HTML. |
| **Proxy configuration** | object | Datacenter | Default is more than enough. |
| **Max concurrent requests** | number | `8` | Feeds read in parallel (5–15 recommended). |

#### 📥 Example input

```json
{
"feedUrls": [
 "https://feeds.bbci.co.uk/news/rss.xml",
 "https://www.theverge.com",
 "https://feeds.megaphone.fm/vergecast"
],
"maxItemsPerFeed": 50,
"keyword": "AI",
"sinceDate": "2026-07-01"
}
````

***

### 📤 Example output

```json
{
  "feedTitle": "The Vergecast",
  "feedUrl": "https://feeds.megaphone.fm/vergecast",
  "title": "You can't ignore Google Zero anymore",
  "link": "https://www.theverge.com/...",
  "author": "The Verge",
  "publishedAt": "2026-07-24T16:21:00.000Z",
  "summary": "This week on the flagship podcast of search results…",
  "content": "This week on the flagship podcast of The Verge…",
  "categories": ["Podcasts", "Tech"],
  "isPodcast": true,
  "mediaUrl": "https://www.podtrac.com/pts/redirect.mp3/...",
  "mediaType": "audio/mpeg",
  "mediaLength": 90123456,
  "durationSeconds": 5627,
  "image": "https://megaphone.imgix.net/...",
  "guid": "abcd-1234"
}
```

***

### 💡 Tips & best practices

- ✅ **Paste websites, not just feeds** — auto-discovery finds the feed for you.
- ✅ **Use the keyword filter** to monitor a topic across dozens of publishers.
- ✅ **Use `since date`** for incremental runs — only pull what's new.
- ✅ **Turn off raw HTML** for clean text; turn it on when you need the original markup.
- ✅ **Schedule it** to build a rolling dataset of new items over time.
- ✅ **Bulk-load** feeds from a file for large monitoring lists.

***

### ❓ FAQ

**Which feed formats are supported?**
RSS 2.0, Atom 1.0, RSS 1.0 (RDF) and podcast (iTunes) feeds.

**I only have the website, not the feed URL.**
Paste the website — the Actor auto-discovers the feed from the page.

**Can I get podcast audio URLs?**
Yes — `mediaUrl`, `mediaType` and `durationSeconds` are returned for podcast items.

**Do I need to code?**
No. Add feed URLs, click Start, export. The API is available for automation.

**How many feeds can I read?**
As many as you like — load them from a list and raise concurrency.

**In what format is the data?**
Structured JSON by default, exportable to CSV, Excel, HTML or via API.

***

### 📊 Output & integrations

Results are stored in a standard Apify dataset. You can:

- 👀 Preview them in a clean **table view** in the Console.
- 💾 Export to **JSON, CSV, Excel, HTML, or RSS**.
- 🔌 Pull them via the **Apify API**.
- 🔗 Push them to **Google Sheets, Make, Zapier, Airbyte** and more.

***

### ⚖️ Legal & responsible use

This Actor reads **publicly published feeds** for legitimate purposes such as monitoring, aggregation and research.

- Respect each publisher's terms of service and copyright — feed content remains the property of its publisher.
- Use collected content in compliance with applicable laws.
- You are responsible for how you use the collected data.

***

### 🛟 Support

Found a bug, need an extra field, or want a tweak? **Open an issue** on the Actor's Issues tab — feedback is welcome and helps improve the Actor.

<p align="center"><b>Happy reading! 📰</b></p>

# Actor input Schema

## `feedUrls` (type: `array`):

One RSS / Atom / RDF / podcast feed URL per line. You can also paste a plain website URL — the Actor will find its feed automatically.

## `startUrls` (type: `array`):

Optional. Load many feed URLs from a file, URL, Google Sheet or Request Queue.

## `maxItemsPerFeed` (type: `integer`):

Maximum number of items to return from each feed. Set to 0 for all available items.

## `keyword` (type: `string`):

Optional. Only return items whose title or content contains this text (case-insensitive).

## `sinceDate` (type: `string`):

Optional. Only return items published on or after this date, e.g. 2026-07-01. Leave blank for all.

## `includeFullContent` (type: `boolean`):

Include the full article/episode content as plain text (in addition to the short summary).

## `includeHtml` (type: `boolean`):

Also include the original HTML of the content. Turn off for clean text only.

## `proxyConfiguration` (type: `object`):

Proxy settings. Datacenter proxies (the default) are more than enough for reading feeds.

## `maxConcurrency` (type: `integer`):

How many feeds to read in parallel. Recommended: 5–15.

## Actor input object example

```json
{
  "feedUrls": [
    "https://www.theverge.com/rss/index.xml"
  ],
  "startUrls": [],
  "maxItemsPerFeed": 50,
  "includeFullContent": true,
  "includeHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Download every feed item collected in this run (JSON, CSV, Excel).

## `runUrl` (type: `string`):

Open this run in the Apify Console.

## `title` (type: `string`):

Item title

## `link` (type: `string`):

Item URL

## `author` (type: `string`):

Item author

## `publishedAt` (type: `string`):

Publish date (ISO 8601)

## `summary` (type: `string`):

Short summary (plain text)

## `content` (type: `string`):

Full content (plain text)

## `categories` (type: `string`):

Item categories / tags

## `feedTitle` (type: `string`):

Source feed title

## `isPodcast` (type: `string`):

Whether the item has audio/video media

## `mediaUrl` (type: `string`):

Enclosure / media URL (audio, video, image)

## `durationSeconds` (type: `string`):

Podcast episode duration in seconds

## `image` (type: `string`):

Item image URL

## `commentsUrl` (type: `string`):

Comments page URL

## `guid` (type: `string`):

Unique item identifier

## `feedUrl` (type: `string`):

Source feed URL

# 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 = {
    "feedUrls": [
        "https://feeds.bbci.co.uk/news/rss.xml",
        "https://news.ycombinator.com/rss"
    ],
    "startUrls": [],
    "maxItemsPerFeed": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/rss-feed-reader").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 = {
    "feedUrls": [
        "https://feeds.bbci.co.uk/news/rss.xml",
        "https://news.ycombinator.com/rss",
    ],
    "startUrls": [],
    "maxItemsPerFeed": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/rss-feed-reader").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 '{
  "feedUrls": [
    "https://feeds.bbci.co.uk/news/rss.xml",
    "https://news.ycombinator.com/rss"
  ],
  "startUrls": [],
  "maxItemsPerFeed": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/rss-feed-reader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RSS Feed Reader – Parse RSS, Atom & Podcast Feeds to JSON",
        "description": "Read any RSS, Atom, RDF or podcast feed and get clean, structured items: title, link, author, date, full content, categories, media/enclosure and podcast duration. Auto-discovers the feed from a website URL. Filter by keyword or date. Export to JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "O6BrHRbdD2TExhV4c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~rss-feed-reader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-rss-feed-reader",
                "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/haketa~rss-feed-reader/runs": {
            "post": {
                "operationId": "runs-sync-haketa-rss-feed-reader",
                "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/haketa~rss-feed-reader/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-rss-feed-reader",
                "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": {
                    "feedUrls": {
                        "title": "Feed URLs",
                        "type": "array",
                        "description": "One RSS / Atom / RDF / podcast feed URL per line. You can also paste a plain website URL — the Actor will find its feed automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Feed URLs from file / list (advanced)",
                        "type": "array",
                        "description": "Optional. Load many feed URLs from a file, URL, Google Sheet or Request Queue.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItemsPerFeed": {
                        "title": "Max items per feed",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of items to return from each feed. Set to 0 for all available items.",
                        "default": 0
                    },
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Optional. Only return items whose title or content contains this text (case-insensitive)."
                    },
                    "sinceDate": {
                        "title": "Only items since (date)",
                        "type": "string",
                        "description": "Optional. Only return items published on or after this date, e.g. 2026-07-01. Leave blank for all."
                    },
                    "includeFullContent": {
                        "title": "Include full content",
                        "type": "boolean",
                        "description": "Include the full article/episode content as plain text (in addition to the short summary).",
                        "default": true
                    },
                    "includeHtml": {
                        "title": "Include raw HTML content",
                        "type": "boolean",
                        "description": "Also include the original HTML of the content. Turn off for clean text only.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies (the default) are more than enough for reading feeds.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many feeds to read in parallel. Recommended: 5–15.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
