# Ground News Bias & Coverage Scraper (`automation-lab/ground-news-bias-coverage-scraper`) Actor

📰 Extract Ground News top stories with left, center, and right coverage splits, factuality, ownership, blindspot context, and original source articles.

- **URL**: https://apify.com/automation-lab/ground-news-bias-coverage-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 story clusters

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

## Ground News Bias & Coverage Scraper

Turn the public Ground News homepage into structured story clusters with political coverage splits, factuality, ownership, blindspot context, and original source articles.

This Apify Actor is built for scheduled media monitoring. It collects the current top-story feed without a Ground News account, browser, or API key and saves clean JSON, CSV, Excel, XML, or RSS-ready records in an Apify dataset.

### What does Ground News Bias & Coverage Scraper do?

The Actor fetches the anonymous public homepage at `ground.news` and emits one record per visible top-story cluster.

Each record can include:

- 📰 Story ID, title, slug, summary, and timestamp
- ⚖️ Left, center, and right source counts and percentages
- 🔎 Ground News coverage-profile or blindspot statement
- ✅ Factuality distribution across contributing outlets
- 🏢 Ownership distribution across contributing outlets
- 🧭 Topics, people, organizations, and places
- 🔗 Available source article URLs, dates, outlets, and bias labels
- 🖼️ Story image and attribution

### Who is it for?

#### PR and communications teams

Track whether a developing story is receiving balanced, one-sided, or rapidly changing coverage. Schedule snapshots and compare them in your BI tool.

#### Media researchers

Study outlet diversity, political coverage, factuality, and ownership without manually opening every Ground News cluster.

#### OSINT and risk analysts

Collect source links and narrative context for current high-impact stories. Preserve a timestamped evidence trail in a dataset.

#### Newsroom and editorial teams

Find stories with unusual coverage profiles and inspect the available original reporting from multiple outlets.

### Why use this Ground News scraper?

A conventional news scraper returns articles one by one. Ground News groups reporting about the same event and enriches that cluster with media-context signals.

This Actor preserves those relationships. Instead of rebuilding clusters from duplicate headlines, you receive a story-level row with nested sources and aggregate political coverage.

Benefits include:

- No account or API key required for the supported public feed
- HTTP-only execution for fast, economical runs
- Stable story IDs for snapshot deduplication
- Optional nested sources to reduce dataset size when only metrics matter
- Explicit errors if the upstream Next.js payload changes
- Native Apify scheduling, webhooks, API, integrations, and exports

### What Ground News data can I extract?

| Field | Description |
|---|---|
| `storyId` | Ground News story-cluster identifier |
| `title` | Current cluster headline |
| `slug` | Ground News article slug when available |
| `storyUrl` | Link to the Ground News cluster |
| `summary` | Public cluster description or summary |
| `publishedAt` | Cluster timestamp |
| `totalSourceCount` | Number of sources reported for the cluster |
| `biasRatedSourceCount` | Number of sources included in political-bias coverage |
| `leftSourceCount` | Left or lean-left source count |
| `centerSourceCount` | Center source count |
| `rightSourceCount` | Right or lean-right source count |
| `leftPercent` | Left coverage percentage |
| `centerPercent` | Center coverage percentage |
| `rightPercent` | Right coverage percentage |
| `coverageProfile` | Human-readable Ground News coverage statement |
| `factualityDistribution` | Counts grouped by factuality level |
| `ownershipDistribution` | Counts grouped by ownership category |
| `interests` | Related topics, people, and organizations |
| `places` | Related countries, regions, or localities |
| `sources` | Available source article and outlet details |
| `scrapedAt` | UTC collection timestamp |

### How to scrape Ground News in 3 steps

1. Open the Actor input page.
2. Choose the maximum number of homepage story clusters and whether to include source articles.
3. Click **Start** and export the resulting dataset.

For a cheap first run, keep the prefilled values: 10 clusters with source details.

### Input

```json
{
  "maxItems": 20,
  "includeSources": true
}
````

#### `maxItems`

Maximum number of current homepage clusters to save. Allowed range: 1–100. Ground News exposes a finite changing feed, so a run can return fewer rows than requested.

#### `includeSources`

When `true`, each story includes available source article URLs, dates, outlet details, and outlet bias labels. Set it to `false` for smaller monitoring snapshots focused on aggregate metrics.

The Actor deliberately does not accept arbitrary URLs or search queries in v1. This keeps the contract aligned with the anonymously verified homepage data.

### Output example

```json
{
  "storyId": "65593e13-5f48-44b7-abf7-45e482684137",
  "title": "Hungary Passes Amendment to End President's Mandate",
  "storyUrl": "https://ground.news/article/hungary-passes-amendment-to-end-presidents-mandate_1cb43d",
  "summary": "Hungary's Parliament passed the amendment...",
  "totalSourceCount": 193,
  "biasRatedSourceCount": 115,
  "leftSourceCount": 46,
  "centerSourceCount": 32,
  "rightSourceCount": 37,
  "leftPercent": 40,
  "centerPercent": 28,
  "rightPercent": 32,
  "coverageProfile": "This news story only has 28% Center political bias coverage",
  "factualityDistribution": {
    "low": 1,
    "mixed": 14,
    "high": 85,
    "unknown": 86,
    "veryHigh": 7
  },
  "sources": [
    {
      "url": "https://www.reuters.com/...",
      "outletName": "Reuters",
      "outletBias": "center"
    }
  ],
  "scrapedAt": "2026-07-15T00:00:00.000Z"
}
```

Fields that Ground News does not expose for a particular card are omitted instead of being filled with misleading null values.

### Political bias coverage fields

Coverage percentages describe the mix of bias-rated sources in the story cluster. They do **not** claim that the event itself, the headline, or every article has a political bias.

Ground News can use labels such as `leanLeft`, `center`, and `leanRight` on nested outlets. The aggregate left/center/right fields are retained exactly as supplied in the public cluster data.

Use these values as research signals and review the linked sources before drawing conclusions.

### Factuality and ownership distributions

`factualityDistribution` can include categories such as `veryLow`, `low`, `mixed`, `high`, `veryHigh`, and `unknown`.

`ownershipDistribution` can include categories such as media conglomerate, billionaire, corporation, government, private equity, independent, telecom, and other.

These are count distributions, not percentages. Category availability varies by story and source coverage.

### Source article details

When `includeSources` is enabled, each nested source can contain:

- Original article URL
- Article publication timestamp
- Outlet ID, name, and slug
- Outlet political-bias label
- Outlet icon URL

The number of nested source objects may be lower than `totalSourceCount`. The total is Ground News's cluster total; the embedded homepage payload can expose only a selection of source records.

### How much does it cost to scrape Ground News?

The Actor uses pay-per-event pricing:

- **Start:** $0.005 per run
- **Story cluster:** $0.000054298 on FREE, $0.000047215 on BRONZE, $0.000036828 on SILVER, $0.000028329 on GOLD, $0.000018886 on PLATINUM, and $0.00001322 on DIAMOND

Higher subscription tiers receive lower per-cluster prices. You can set `maxItems` before starting a run and monitor charges in the run details.

The Actor uses 256 MB by default and avoids browser startup, which keeps compute overhead low. Final live prices are always shown on the Actor page before you run it.

### Scheduling a Ground News monitor

Use an Apify schedule to run hourly or daily.

A typical workflow is:

1. Run with `maxItems: 50` and `includeSources: true`.
2. Send the dataset webhook to a warehouse or automation platform.
3. Upsert by `storyId` and retain `scrapedAt` as the snapshot time.
4. Alert when left/center/right percentages or source totals change materially.

Scheduled runs capture the current feed; they do not backfill historical homepage states.

### Integrations

#### Google Sheets

Send each completed dataset to a sheet for a daily editorial or communications briefing.

#### Slack and Microsoft Teams

Use a webhook or Make/Zapier workflow to post clusters whose coverage profile matches your risk criteria.

#### Snowflake, BigQuery, and PostgreSQL

Load snapshots into a warehouse and model changes by `storyId` and `scrapedAt`.

#### AI and RAG workflows

Feed summaries and source URLs into a downstream enrichment pipeline. Keep the Ground News metrics as structured metadata for filtering and citations.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ground-news-bias-coverage-scraper').call({
  maxItems: 20,
  includeSources: true,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/ground-news-bias-coverage-scraper").call(
    run_input={"maxItems": 20, "includeSources": True}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~ground-news-bias-coverage-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":20,"includeSources":true}'
```

Read the dataset after the run finishes through the `defaultDatasetId` returned by the API.

### Use with Apify MCP

#### Claude Code setup

Connect the hosted Apify MCP server with the exact HTTP transport command:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/ground-news-bias-coverage-scraper"
```

#### Claude Desktop setup

Add this hosted server entry to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/ground-news-bias-coverage-scraper"
    }
  }
}
```

#### Cursor setup

Add the same hosted URL as a remote MCP server in **Cursor Settings → Tools & MCP**.

#### VS Code setup

In VS Code, open the MCP server configuration and add `https://mcp.apify.com?tools=automation-lab/ground-news-bias-coverage-scraper` as an HTTP server.

For clients that run a local stdio server, use:

```bash
npx -y @apify/actors-mcp-server --actors automation-lab/ground-news-bias-coverage-scraper
```

Example prompts:

- “Collect the top 20 Ground News clusters and rank them by right coverage percentage.”
- “Extract source URLs for today's most widely covered story.”
- “Compare ownership distributions across current political stories.”

### Tips for reliable monitoring

- Use `storyId` rather than title as your deduplication key.
- Keep `scrapedAt` when storing repeated snapshots.
- Set `includeSources` to `false` when you need only aggregate metrics.
- Do not assume every story has political-bias, factuality, or ownership enrichment.
- Treat source totals and nested-source counts as different concepts.
- Retry later if Ground News is temporarily unavailable.

### Limitations

The v1 Actor supports only the public Ground News homepage feed.

It does not:

- Search Ground News
- Access account-only or paid features
- Scrape arbitrary topic, local, or story-detail pages
- Guarantee historical coverage
- Guarantee that every source counted by Ground News appears as a nested object
- Independently verify Ground News classifications

The homepage and its Next.js payload can change. The Actor detects missing Flight data and fails clearly rather than silently returning an empty dataset.

### Data freshness

Results reflect the homepage at run time. Headlines, summaries, source totals, and distributions can change as Ground News updates a cluster.

For longitudinal analysis, schedule recurring runs and retain each `scrapedAt` snapshot. For a one-time briefing, use the latest successful dataset.

### Is scraping Ground News legal?

The Actor accesses anonymously available public homepage data and does not bypass login or paid access.

Scraping legality depends on jurisdiction, purpose, contract terms, and the data you store. You are responsible for reviewing Ground News's terms, respecting intellectual-property rights, and using source content lawfully.

Do not treat political-bias or factuality labels as definitive claims about individuals. Preserve attribution and linked sources when publishing analysis.

### Troubleshooting

#### Why did I receive fewer rows than `maxItems`?

The homepage is finite and changes throughout the day. `maxItems` is a ceiling, not a promise. Ground News may expose fewer unique clusters at run time.

#### Why is `sources.length` lower than `totalSourceCount`?

`totalSourceCount` is the reported cluster total. The homepage payload can embed only an available subset of source article records.

#### Why are bias percentages missing?

Not every cluster has enough bias-rated sources or a public coverage profile. Missing metrics are omitted rather than estimated.

#### The run says the page format changed

Retry once to rule out a transient response. If it persists, share the run with support so the Flight parser can be updated to Ground News's current schema.

### FAQ

#### Does this Actor need a Ground News account?

No. The supported homepage feed is public and anonymously accessible.

#### Does it use a browser or residential proxy?

No by default. It uses a direct HTTP request with conservative retries, reducing run time and compute use.

#### Can I scrape a specific story URL?

Not in v1. The input intentionally matches the verified homepage scope.

#### Are the bias ratings generated by this Actor?

No. The Actor structures the fields Ground News exposes publicly. It does not invent, score, or validate political-bias classifications.

#### Can I export to CSV or Excel?

Yes. Open the run dataset and choose JSON, CSV, Excel, XML, or another supported Apify export format.

#### Can I run it every hour?

Yes. Create an Apify schedule and connect a webhook or integration to process each completed dataset.

### Related news scrapers

Combine this Actor with other Automation Lab tools:

- [Google News Scraper](https://apify.com/automation-lab/google-news-scraper) for keyword-driven article discovery
- [News & Article Extractor](https://apify.com/automation-lab/news-article-extractor) for full article-body extraction from source URLs
- [Techmeme Scraper](https://apify.com/automation-lab/techmeme-scraper) for technology-news headlines and clusters

Use Ground News Bias & Coverage Scraper when you need cluster-level political coverage, factuality, ownership, and blindspot context. Use the related actors for broader discovery or downstream article extraction.

### Support

If a run fails repeatedly or a field disappears after a Ground News update, share the Apify run with support. Include the input and the approximate time the public page was checked.

For reproducible results, avoid editing exported records before reporting an issue and mention whether `includeSources` was enabled.

# Actor input Schema

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

Maximum number of public Ground News homepage story clusters to emit. The homepage contains a finite, changing feed.

## `includeSources` (type: `boolean`):

Include available article URLs, dates, outlets, and outlet bias labels inside each story record.

## Actor input object example

```json
{
  "maxItems": 10,
  "includeSources": true
}
```

# 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 = {
    "maxItems": 10,
    "includeSources": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ground-news-bias-coverage-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "includeSources": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ground-news-bias-coverage-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "includeSources": true
}' |
apify call automation-lab/ground-news-bias-coverage-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/ground-news-bias-coverage-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ground News Bias & Coverage Scraper",
        "description": "📰 Extract Ground News top stories with left, center, and right coverage splits, factuality, ownership, blindspot context, and original source articles.",
        "version": "0.1",
        "x-build-id": "OgxPxtceDqNfd09oN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ground-news-bias-coverage-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ground-news-bias-coverage-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/automation-lab~ground-news-bias-coverage-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ground-news-bias-coverage-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/automation-lab~ground-news-bias-coverage-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ground-news-bias-coverage-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Maximum story clusters",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of public Ground News homepage story clusters to emit. The homepage contains a finite, changing feed.",
                        "default": 20
                    },
                    "includeSources": {
                        "title": "Include nested source articles",
                        "type": "boolean",
                        "description": "Include available article URLs, dates, outlets, and outlet bias labels inside each story record.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
