# Medium Articles Scraper (`fetch_cat/medium-articles-scraper`) Actor

Scrape public Medium article metadata from RSS feeds by tag, author, publication, or feed URL.

- **URL**: https://apify.com/fetch\_cat/medium-articles-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** News, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 article rows

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/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

## Medium Articles Scraper

Collect public Medium article metadata by tag, author, publication, or supported Medium feed URL. The Actor focuses on reliable public metadata and does not require a Medium account.

Use it for content research, AI/RAG dataset preparation, editorial monitoring, trend analysis, and competitive intelligence workflows that need recent public Medium article metadata with predictable CSV, JSON, Excel, API, and webhook exports.

### At a glance

- **Primary job**: Scrape recent public Medium RSS article metadata and snippets.
- **Input**: Medium tags, author handles, publication slugs, or Medium `/feed/...` URLs.
- **Output**: One charged dataset row per article plus free diagnostic rows for unsupported or failed sources.
- **Best for**: Content marketers, editorial researchers, AI dataset builders, trend analysts, and monitoring workflows.

### Common workflows

- **Topic research**: Track recent Medium posts for tags such as `artificial-intelligence` or `data-science`.
- **Author monitoring**: Collect recent public posts from a Medium creator handle such as `@ev`.
- **Publication monitoring**: Watch a Medium publication feed such as `the-generator`.
- **AI/RAG datasets**: Export public titles, URLs, tags, snippets, dates, and image URLs for downstream enrichment.
- **Automation**: Schedule repeat runs, compare datasets over time, or trigger webhooks when new article URLs appear.

### Input recipes

- **Small tag smoke test**: `tags: ["artificial-intelligence"]`, `maxItems: 10`.
- **Author monitoring**: `authors: ["@ev"]`, `maxItems: 10`.
- **Publication feed**: `publications: ["the-generator"]`, `maxItems: 10`.
- **Multi-topic comparison**: `tags: ["artificial-intelligence", "data-science"]`, `maxItemsPerSource: 10`, `maxItems: 20`.
- **Direct feed URL**: `startUrls: [{ "url": "https://medium.com/feed/tag/data-science" }]`.

### What data can you extract?

| Field | Description |
| --- | --- |
| `itemType` | `article` for result rows or `error` for source diagnostics. |
| `input`, `inputType`, `feedUrl`, `feedTitle` | Source input, normalized type, resolved feed URL, and source title. |
| `articleId`, `guid`, `url`, `canonicalUrl` | Article identifiers and links derived from the RSS feed. |
| `title`, `subtitle`, `authorName`, `publicationName` | Public article metadata when exposed by RSS. |
| `publishedAt`, `updatedAt`, `rawPublishedAt`, `rawUpdatedAt` | Parsed and raw RSS date values. |
| `tags`, `tagsNormalized` | RSS categories and normalized tag slugs. |
| `snippetHtml`, `snippetText`, `imageUrl` | Feed description/content fragment, plain text, and first image URL when available. |
| `readingTime`, `readingTimeMethod` | Estimated reading time from feed text. |
| `isMemberOnly` | Best-effort public indicator when detectable; otherwise `null`. |
| `sourceInputs`, `scrapedAt`, `status`, `errorCode`, `errorMessage` | Traceability and diagnostics for partial failures. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Medium feed or page URLs | `startUrls` | Direct `/feed/...` URLs, tag URLs, author URLs, publication URLs. | `https://medium.com/feed/tag/artificial-intelligence` |
| Tags | `tags` | Topic feeds. Spaces become Medium tag slugs. | `data science` |
| Authors | `authors` | Author handles or profile URLs. | `@ev` |
| Publications | `publications` | Publication slugs or URLs. | `the-generator` |
| Maximum article rows | `maxItems` | Cap charged article rows across all sources. | `25` |
| Maximum articles per source | `maxItemsPerSource` | Cap rows from each feed. | `10` |
| Include snippet HTML | `includeSnippetHtml` | Save raw feed HTML in addition to `snippetText`. | `true` |
| Include article details | `includeArticleDetails` | Reserved for future safe enrichment; V1 keeps this disabled. | `false` |
| Proxy configuration | `proxyConfiguration` | Optional proxy settings; usually not needed for public Medium sources. | `{ "useApifyProxy": false }` |

### Example input

```json
{
  "tags": ["artificial-intelligence"],
  "authors": ["@ev"],
  "publications": ["the-generator"],
  "maxItems": 25,
  "maxItemsPerSource": 10,
  "includeSnippetHtml": true
}
````

### Example output

```json
{
  "itemType": "article",
  "input": "artificial-intelligence",
  "inputType": "tag",
  "feedUrl": "https://medium.com/feed/tag/artificial-intelligence",
  "feedTitle": "Medium - Artificial Intelligence",
  "articleId": "abc123def456",
  "guid": "https://medium.com/p/abc123def456",
  "url": "https://medium.com/example/story-abc123def456",
  "canonicalUrl": "https://medium.com/example/story-abc123def456",
  "title": "Example Medium story",
  "authorName": "Example Author",
  "publicationName": "Medium - Artificial Intelligence",
  "publishedAt": "2026-07-16T08:00:00.000Z",
  "tags": ["Artificial Intelligence"],
  "tagsNormalized": ["artificial-intelligence"],
  "snippetText": "Short public feed snippet...",
  "imageUrl": "https://miro.medium.com/example.png",
  "readingTime": 1,
  "readingTimeMethod": "estimated_from_feed_words",
  "isMemberOnly": null,
  "source": "medium-rss",
  "sourceInputs": ["artificial-intelligence"],
  "scrapedAt": "2026-07-16T10:00:00.000Z",
  "status": "ok",
  "errorCode": null
}
```

### Pricing

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond | Charged when |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
| Run start | `$0.005` | `$0.005` | `$0.005` | `$0.005` | `$0.005` | `$0.005` | Once when the Actor starts. |
| Article row | `$0.00095` | `$0.00080` | `$0.00065` | `$0.00050` | `$0.00035` | `$0.00025` | Each article row saved to the dataset. Diagnostic rows are not charged as article rows. |

### Tips for best results

- **Use feed-shaped inputs**: Direct `https://medium.com/feed/...` URLs are most reliable.
- **Prefer specific sources**: Split broad monitoring into focused tag, author, or publication feeds.
- **Start small**: Use `maxItems: 10` while checking output quality and spend.
- **Expect feed limits**: Medium RSS feeds usually expose recent items, not unlimited history.

### API usage

Node.js:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/medium-articles-scraper").call({
  tags: ["artificial-intelligence"],
  maxItems: 10
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/medium-articles-scraper").call(run_input={
    "authors": ["@ev"],
    "maxItems": 10,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~medium-articles-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"publications":["the-generator"],"maxItems":10}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/medium-articles-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/medium-articles-scraper"
    }
  }
}
```

Example prompt: "Run Medium Articles Scraper for the artificial-intelligence tag and summarize the latest titles and tags."

### Limits and caveats

- **Metadata-first V1**: Full article bodies, claps, responses, and native search ranking are not scraped in this version.
- **No account data**: The Actor does not use Medium cookies, logins, private drafts, recommendations, stats, or member-only bypasses.
- **Diagnostics**: Unsupported direct HTML URLs produce clear diagnostic rows instead of silent empty success.
- **Freshness**: RSS feeds expose recent public items and can change between runs.

### Legality and responsible use

Process only public data that you are allowed to access. Follow Medium's terms, Apify's terms, and applicable laws.

### Related actors

- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper)
- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper)

### FAQ

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Why are some fields empty?

Medium RSS feeds do not expose every field for every item. The Actor leaves unavailable fields empty instead of guessing.

#### Why did I get an error row for a Medium URL?

V1 supports public Medium feeds plus tag, author, and publication inputs. Unsupported direct article/page URLs are reported as diagnostics so runs do not end in silent empty output.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL such as `https://medium.com/feed/tag/artificial-intelligence`.

# Actor input Schema

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

Medium RSS feed URLs are processed directly. Medium tag, author, and publication URLs are normalized to their public /feed/ routes. Direct article HTML URLs are reported as unsupported diagnostics in V1.

## `tags` (type: `array`):

Medium tags or topics. Spaces are converted to Medium tag slugs, for example `data science` becomes `/feed/tag/data-science`.

## `authors` (type: `array`):

Medium author handles or profile URLs, for example `@ev` or `https://medium.com/@ev`.

## `publications` (type: `array`):

Medium publication slugs or URLs, for example `the-generator` or `https://medium.com/the-generator`.

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

Maximum number of article rows to save across all sources. Diagnostic rows for failed sources may be added in addition to this cap and are not charged as article rows.

## `maxItemsPerSource` (type: `integer`):

Maximum article rows to read from each individual feed before moving to the next source.

## `includeSnippetHtml` (type: `boolean`):

Save the raw feed description/content HTML fragment when Medium includes it. Plain text is always saved as `snippetText`.

## `includeArticleDetails` (type: `boolean`):

Reserved for future safe public article enrichment. V1 is RSS-first and does not fetch direct article HTML pages.

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

Optional Apify proxy settings. Public Medium RSS feeds usually work without a proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://medium.com/feed/tag/artificial-intelligence"
    },
    {
      "url": "https://medium.com/feed/@ev"
    },
    {
      "url": "https://medium.com/feed/the-generator"
    }
  ],
  "tags": [
    "artificial-intelligence",
    "data-science"
  ],
  "authors": [
    "@ev"
  ],
  "publications": [
    "the-generator"
  ],
  "maxItems": 20,
  "maxItemsPerSource": 20,
  "includeSnippetHtml": true,
  "includeArticleDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://medium.com/feed/tag/artificial-intelligence"
        },
        {
            "url": "https://medium.com/feed/@ev"
        },
        {
            "url": "https://medium.com/feed/the-generator"
        }
    ],
    "tags": [
        "artificial-intelligence",
        "data-science"
    ],
    "authors": [
        "@ev"
    ],
    "publications": [
        "the-generator"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/medium-articles-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 = {
    "startUrls": [
        { "url": "https://medium.com/feed/tag/artificial-intelligence" },
        { "url": "https://medium.com/feed/@ev" },
        { "url": "https://medium.com/feed/the-generator" },
    ],
    "tags": [
        "artificial-intelligence",
        "data-science",
    ],
    "authors": ["@ev"],
    "publications": ["the-generator"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/medium-articles-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 '{
  "startUrls": [
    {
      "url": "https://medium.com/feed/tag/artificial-intelligence"
    },
    {
      "url": "https://medium.com/feed/@ev"
    },
    {
      "url": "https://medium.com/feed/the-generator"
    }
  ],
  "tags": [
    "artificial-intelligence",
    "data-science"
  ],
  "authors": [
    "@ev"
  ],
  "publications": [
    "the-generator"
  ]
}' |
apify call fetch_cat/medium-articles-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Medium Articles Scraper",
        "description": "Scrape public Medium article metadata from RSS feeds by tag, author, publication, or feed URL.",
        "version": "0.1",
        "x-build-id": "ehAxzcWUfe0X5PcFZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~medium-articles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-medium-articles-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/fetch_cat~medium-articles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-medium-articles-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/fetch_cat~medium-articles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-medium-articles-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": {
                    "startUrls": {
                        "title": "Medium feed or page URLs",
                        "type": "array",
                        "description": "Medium RSS feed URLs are processed directly. Medium tag, author, and publication URLs are normalized to their public /feed/ routes. Direct article HTML URLs are reported as unsupported diagnostics in V1.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "tags": {
                        "title": "Tags",
                        "type": "array",
                        "description": "Medium tags or topics. Spaces are converted to Medium tag slugs, for example `data science` becomes `/feed/tag/data-science`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "authors": {
                        "title": "Authors",
                        "type": "array",
                        "description": "Medium author handles or profile URLs, for example `@ev` or `https://medium.com/@ev`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publications": {
                        "title": "Publications",
                        "type": "array",
                        "description": "Medium publication slugs or URLs, for example `the-generator` or `https://medium.com/the-generator`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum article rows",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of article rows to save across all sources. Diagnostic rows for failed sources may be added in addition to this cap and are not charged as article rows.",
                        "default": 20
                    },
                    "maxItemsPerSource": {
                        "title": "Maximum articles per source",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum article rows to read from each individual feed before moving to the next source.",
                        "default": 20
                    },
                    "includeSnippetHtml": {
                        "title": "Include snippet HTML",
                        "type": "boolean",
                        "description": "Save the raw feed description/content HTML fragment when Medium includes it. Plain text is always saved as `snippetText`.",
                        "default": true
                    },
                    "includeArticleDetails": {
                        "title": "Include article details (reserved)",
                        "type": "boolean",
                        "description": "Reserved for future safe public article enrichment. V1 is RSS-first and does not fetch direct article HTML pages.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Public Medium RSS feeds usually work without a proxy.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
