# DEV.to Articles Scraper (`fetch_cat/devto-articles-scraper`) Actor

Scrape public DEV Community articles by tag, username, or article URL with metadata, engagement metrics, authors, tags, and optional body content.

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

## Pricing

from $0.15 / 1,000 article saveds

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

## DEV.to Articles Scraper

Extract public DEV Community articles by tag, author username, or exact article URL. The actor returns clean article metadata, author details, tags, engagement counts, publish dates, links, images, and optional body Markdown/HTML for content research and automation.

### Value proposition

DEV.to Articles Scraper helps developer relations, content, SEO, and research teams turn public DEV Community articles into structured datasets.

### What data it exports

Use it to collect articles from tags, authors, or known URLs, then export article metadata, engagement, author profiles, media links, and optional body text.

### Why use this actor?

- Track developer topics such as `javascript`, `webdev`, `ai`, `python`, and `devops`
- Monitor authors, advocates, competitors, and community influencers
- Build content calendars, newsletters, SEO research sheets, and RAG/LLM datasets
- Export ready-to-use JSON, CSV, Excel, XML, HTML, or API results from Apify
- No DEV.to login, API key, or browser session is required for public articles

### Example input

Start from a verified public Example task when you want a ready-made configuration:

- [Scrape the latest JavaScript articles from DEV.to](https://apify.com/fetch_cat/devto-articles-scraper/examples/latest-javascript-articles)
- [Find top DEV.to AI articles from the last 7 days](https://apify.com/fetch_cat/devto-articles-scraper/examples/top-ai-articles-week)
- [Scrape articles by a DEV.to author](https://apify.com/fetch_cat/devto-articles-scraper/examples/devto-author-articles)
- [Extract DEV.to article bodies with Markdown and HTML](https://apify.com/fetch_cat/devto-articles-scraper/examples/devto-article-body)

### Output example

```json
{
  "id": 4110750,
  "title": "I Got Tired of Maintaining Frontend Code. So I Built a Declarative UI Runtime.",
  "description": "Here is a question that sounds simple until you've actually shipped a UI...",
  "url": "https://dev.to/thuangf45/i-got-tired-of-maintaining-frontend-code-so-i-built-a-declarative-ui-runtime-5dbl",
  "canonicalUrl": "https://dev.to/thuangf45/i-got-tired-of-maintaining-frontend-code-so-i-built-a-declarative-ui-runtime-5dbl",
  "slug": "i-got-tired-of-maintaining-frontend-code-so-i-built-a-declarative-ui-runtime-5dbl",
  "path": "/thuangf45/i-got-tired-of-maintaining-frontend-code-so-i-built-a-declarative-ui-runtime-5dbl",
  "publishedAt": "2026-07-10T06:15:15Z",
  "editedAt": null,
  "readablePublishDate": "Jul 10",
  "readingTimeMinutes": 16,
  "language": "en",
  "tags": ["javascript", "webdev", "showdev", "architecture"],
  "commentsCount": 9,
  "publicReactionsCount": 28,
  "positiveReactionsCount": 28,
  "coverImage": "https://media2.dev.to/.../cover.png",
  "socialImage": "https://media2.dev.to/.../social.png",
  "authorName": "Thuangf45",
  "authorUsername": "thuangf45",
  "authorUserId": 3592872,
  "authorProfileImage": "https://media2.dev.to/.../profile.png",
  "authorGithubUsername": "thuangf45",
  "authorTwitterUsername": null,
  "authorWebsiteUrl": "https://thuangf45.github.io/",
  "scrapedAt": "2026-07-10T08:00:00.000Z",
  "inputMode": "tag",
  "sourceTag": "javascript"
}
````

When `includeArticleBody` is enabled, each row can also include `bodyMarkdown` and `bodyHtml`.

### Input settings

| Field | Type | Description | Default |
| --- | --- | --- | --- |
| `mode` | string | `tag`, `username`, or `articleUrls` | `tag` |
| `tags` | string\[] | DEV tags to scrape, without `#`; used in tag mode | `["javascript", "webdev"]` |
| `usernames` | string\[] | DEV usernames to scrape, without `@`; used in username mode | `["ben"]` |
| `articleUrls` | array | Exact public DEV article URLs; used in article URL mode | sample DEV URL |
| `sort` | string | `latest` or `top` where supported | `latest` |
| `topTimeframeDays` | integer | Top-article window: `1`, `7`, `30`, or `365` | `7` |
| `maxItems` | integer | Maximum total articles saved across all sources | `20` |
| `includeArticleBody` | boolean | Add body Markdown/HTML fields by fetching article details | `false` |

### Output fields

The dataset contains one row per public DEV article:

- Article identity: `id`, `title`, `description`, `url`, `canonicalUrl`, `slug`, `path`
- Dates and language: `publishedAt`, `editedAt`, `readablePublishDate`, `language`
- Engagement: `commentsCount`, `publicReactionsCount`, `positiveReactionsCount`, `readingTimeMinutes`
- Tags and media: `tags`, `tagList`, `coverImage`, `socialImage`
- Author: `authorName`, `authorUsername`, `authorUserId`, `authorProfileImage`, `authorGithubUsername`, `authorTwitterUsername`, `authorWebsiteUrl`
- Optional body: `bodyMarkdown`, `bodyHtml`
- Provenance: `scrapedAt`, `inputMode`, `sourceTag`, `sourceUsername`, `sourceArticleUrl`

### Use cases

- **Developer relations monitoring**: track how often products, frameworks, and languages are discussed.
- **Content marketing research**: find article ideas, authors, and high-engagement topics.
- **Newsletter curation**: schedule recurring tag runs and rank results by reactions or comments.
- **SEO and competitive intelligence**: compare titles, tags, publishing cadence, and engagement.
- **LLM/RAG datasets**: collect structured public technical writing with optional article body text.

### Pricing

This actor uses pay-per-event pricing:

- Start event: `$0.005` per run
- Article saved: tiered by Apify plan

| Tier | Price per article | Approx. price per 1,000 articles |
| --- | ---: | ---: |
| Free | `$0.00028199` | `$0.2820` |
| Bronze | `$0.00024521` | `$0.2452` |
| Silver | `$0.00019126` | `$0.1913` |
| Gold | `$0.00014712` | `$0.1471` |
| Platinum | `$0.000098083` | `$0.0981` |
| Diamond | `$0.000068658` | `$0.0687` |

Check the Pricing tab for the live rate once published.

### Tips and limits

- Start with a low `maxItems` value to validate your input cheaply.
- Use `mode: "articleUrls"` when you need guaranteed body extraction for a small set of known articles.
- DEV may occasionally rate-limit high-volume requests; keep scheduled runs reasonable and retry later if the upstream site is busy.
- The actor only collects public article data. It does not access drafts, private dashboards, notifications, or logged-in features.

### API usage

Run the actor from code with the Apify API client.

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/devto-articles-scraper').call({
  mode: 'tag',
  tags: ['javascript'],
  maxItems: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("fetch_cat/devto-articles-scraper").call(run_input={
    "mode": "tag",
    "tags": ["javascript"],
    "maxItems": 20,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

cURL:

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~devto-articles-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"mode":"tag","tags":["javascript"],"maxItems":20}'
```

### MCP and agent usage

Use this actor from AI agents through Apify MCP:

```text
https://mcp.apify.com?tools=fetch_cat/devto-articles-scraper
```

Claude CLI:

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

JSON config:

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

Example prompt:

> Scrape the latest 20 DEV.to articles tagged `ai`, then summarize the top recurring themes by reactions and comments.

### Related actors

- [Hacker News Search Scraper](https://apify.com/fetch_cat/hacker-news-search-scraper) - search developer and startup discussions.
- [GitHub Repositories Search Scraper](https://apify.com/fetch_cat/github-repositories-search-scraper) - collect repositories by topic and keywords.
- [Stack Exchange Questions Scraper](https://apify.com/fetch_cat/stack-exchange-questions-scraper) - monitor developer questions and tags.

### FAQ

**Do I need a DEV.to account or API key?**\
No. The actor collects public article data only.

**Can I get full article text?**\
Yes. Enable `includeArticleBody` to add `bodyMarkdown` and `bodyHtml` when DEV provides body content for the public article.

**Can I scrape multiple tags or users at once?**\
Yes. Add multiple values to `tags` or `usernames`; `maxItems` applies to the whole run.

**Can I export to CSV or Excel?**\
Yes. Open the dataset on Apify and export it as JSON, CSV, Excel, XML, HTML, or via API.

**Is it legal to scrape DEV.to?**\
This actor collects public information. You are responsible for complying with DEV Community terms and applicable laws.

### Support

Questions, bugs, or missing fields? Open an issue on the actor's Issues tab in Apify Console and include:

- Run ID or run URL
- Input JSON you used
- Expected output
- Actual output
- A reproducible public URL, DEV tag, or username

### Changelog

- 2026-07-15 - Feature: Added ready-to-run example tasks on the Apify Store

- 2026-07-15 - Feature: Launched DEV.to Articles Scraper on Apify Store

# Actor input Schema

## `mode` (type: `string`):

Choose whether to collect articles from tags, usernames, or exact article URLs.

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

DEV tags to scrape, without #. Used when scrape mode is Tags.

## `usernames` (type: `array`):

DEV usernames to scrape, without @. Used when scrape mode is Usernames.

## `articleUrls` (type: `array`):

Exact public DEV article URLs. Used when scrape mode is Article URLs.

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

Latest uses DEV's default newest feed. Top uses DEV's public top-articles filter where supported.

## `topTimeframeDays` (type: `integer`):

When Sort order is Top, request top articles for this time window. Common values are 1, 7, 30, or 365.

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

Maximum total article records to save across all selected tags, usernames, or URLs.

## `includeArticleBody` (type: `boolean`):

Fetch each article detail page through DEV's public article endpoint and include markdown and HTML body fields.

## Actor input object example

```json
{
  "mode": "tag",
  "tags": [
    "javascript",
    "webdev"
  ],
  "usernames": [
    "ben"
  ],
  "articleUrls": [
    {
      "url": "https://dev.to/ben/meme-monday-590l"
    }
  ],
  "sort": "latest",
  "topTimeframeDays": 7,
  "maxItems": 20,
  "includeArticleBody": false
}
```

# Actor output Schema

## `articles` (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 = {
    "mode": "tag",
    "tags": [
        "javascript",
        "webdev"
    ],
    "usernames": [
        "ben"
    ],
    "articleUrls": [
        {
            "url": "https://dev.to/ben/meme-monday-590l"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/devto-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 = {
    "mode": "tag",
    "tags": [
        "javascript",
        "webdev",
    ],
    "usernames": ["ben"],
    "articleUrls": [{ "url": "https://dev.to/ben/meme-monday-590l" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/devto-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 '{
  "mode": "tag",
  "tags": [
    "javascript",
    "webdev"
  ],
  "usernames": [
    "ben"
  ],
  "articleUrls": [
    {
      "url": "https://dev.to/ben/meme-monday-590l"
    }
  ],
  "maxItems": 20
}' |
apify call fetch_cat/devto-articles-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DEV.to Articles Scraper",
        "description": "Scrape public DEV Community articles by tag, username, or article URL with metadata, engagement metrics, authors, tags, and optional body content.",
        "version": "0.1",
        "x-build-id": "dnJJxN0SNzANLpfZa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~devto-articles-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-devto-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~devto-articles-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-devto-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~devto-articles-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-devto-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scrape mode",
                        "enum": [
                            "tag",
                            "username",
                            "articleUrls"
                        ],
                        "type": "string",
                        "description": "Choose whether to collect articles from tags, usernames, or exact article URLs.",
                        "default": "tag"
                    },
                    "tags": {
                        "title": "Tags",
                        "type": "array",
                        "description": "DEV tags to scrape, without #. Used when scrape mode is Tags.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "DEV usernames to scrape, without @. Used when scrape mode is Usernames.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "articleUrls": {
                        "title": "Article URLs",
                        "type": "array",
                        "description": "Exact public DEV article URLs. Used when scrape mode is Article URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "latest",
                            "top"
                        ],
                        "type": "string",
                        "description": "Latest uses DEV's default newest feed. Top uses DEV's public top-articles filter where supported.",
                        "default": "latest"
                    },
                    "topTimeframeDays": {
                        "title": "Top timeframe (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "When Sort order is Top, request top articles for this time window. Common values are 1, 7, 30, or 365.",
                        "default": 7
                    },
                    "maxItems": {
                        "title": "Maximum articles",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total article records to save across all selected tags, usernames, or URLs.",
                        "default": 20
                    },
                    "includeArticleBody": {
                        "title": "Include article body",
                        "type": "boolean",
                        "description": "Fetch each article detail page through DEV's public article endpoint and include markdown and HTML body fields.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
