# Revolut Pulse Mcp 1 (`revolut-pulse/revolut-pulse-mcp-1`) Actor

revolut-pulse is a MCP server that gives AI assistants  live access to financial markets, Revolut's tradable asset catalog, and SEC insider trading data — with zero API keys needed for market data.
It also ships a programmatic SEO engine that generates hundreds of financial pages targeting queries

- **URL**: https://apify.com/revolut-pulse/revolut-pulse-mcp-1.md
- **Developed by:** [george pappas](https://apify.com/revolut-pulse) (community)
- **Categories:** SEO tools, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## revolut-pulse-mcp — Real-Time Stock, Crypto & Insider Trading MCP Server

> **The most complete MCP server for Revolut trading intelligence.**  
> Real-time prices, SEC insider filings, Revolut availability checks, and a built-in programmatic SEO engine — all in one Python server.

[![Python](https://img.shields.io/badge/Python-3.10%2B-blue?logo=python)](https://python.org)
[![FastMCP](https://img.shields.io/badge/FastMCP-protocol-green)](https://github.com/jlowin/fastmcp)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow)](LICENSE)
[![MCP Transport](https://img.shields.io/badge/Transport-HTTP%20%7C%20stdio-purple)](https://modelcontextprotocol.io)
[![Deploy: Cloud Run](https://img.shields.io/badge/Deploy-Google%20Cloud%20Run-orange?logo=googlecloud)](https://cloud.google.com/run)

---

### What Is revolut-pulse-mcp?

**revolut-pulse-mcp** is a [Model Context Protocol (MCP)](https://modelcontextprotocol.io) server that gives AI assistants (Claude, GPT-4, Cursor, etc.) live access to financial markets, Revolut's tradable asset catalog, and SEC insider trading data — with zero API keys needed for market data.

It also ships a **programmatic SEO engine** that generates hundreds of financial pages targeting queries like:

- *"Is NVDA available on Revolut?"*
- *"How to buy Bitcoin on Revolut"*
- *"Revolut vs eToro for TSLA"*
- *"Insider trading alerts for S&P 500 stocks"*

**No API keys required** for stocks, crypto, and insider data.  
Banking tools degrade gracefully when credentials are not configured.

---

### Key Features

#### 📈 Real-Time Market Data (No Key Required)
- Live stock & ETF prices via Yahoo Finance (~15 min delay)
- Live crypto prices via Binance WebSocket (real-time)
- Bulk price fetching for up to 20 tickers in one call
- Top crypto movers by 24h volume from Binance
- Market Fear & Greed index via Alternative.me

#### 🕵️ SEC Insider Trading Intelligence
- SEC Form 4 filings parsed in real-time from EDGAR
- CEO/CFO trade detection with severity scoring (EXTREME / HIGH / MODERATE)
- Insider cluster detection — multiple insiders buying the same stock on the same day
- Weekly insider trading summaries by ticker
- Cross-reference: insider trades mapped to Revolut-tradable stocks only

#### 💳 Revolut Integration
- Full stock & crypto catalog — 130+ stocks, 50+ crypto pairs
- Revolut availability check for any ticker
- Open Banking: accounts, balances, transactions, payments (OAuth2)
- Revolut X: crypto orders, OHLC, trade history (Ed25519 signing)
- FX fee calculator by plan (Standard / Premium / Metal)
- Multi-currency balance viewer with GBP equivalents

#### 🧠 AI-Ready Prompts & Resources
- 16 built-in MCP prompts for trading, banking, SEO content generation
- 8 static MCP resources (tradable symbols, plan limits, sector ETFs, SEO keywords)
- Schema-aware structured outputs for every tool

#### 🌐 Programmatic SEO Engine (v3)
- Auto-generates 450+ financial landing pages at deploy time
- Schema.org structured data on every page
- XML sitemap at `/sitemap.xml`
- Targets Revolut-specific long-tail keywords with commercial intent

---

### Quick Start

#### Option 1 — Claude Desktop (stdio)

```json
{
  "mcpServers": {
    "revolut-pulse-mcp": {
      "command": "uv",
      "args": [
        "run", "--with",
        "fastmcp,httpx,beautifulsoup4,pynacl,fastapi,uvicorn",
        "python", "app.py"
      ],
      "cwd": "/path/to/revolut-pulse-mcp"
    }
  }
}
````

#### Option 2 — HTTP Server (Claude.ai / API / Cloud Run)

```bash
git clone https://github.com/gepappas98/revolut-pulse-mcp.git
cd revolut-pulse-mcp
pip install -r requirements.txt
MCP_TRANSPORT=http python app.py
```

Server starts on `http://0.0.0.0:8080`.\
MCP endpoint: `POST /mcp`\
SSE endpoint: `GET /mcp/sse`\
Health check: `GET /ping`

***

### Full Tool Reference (38 Tools)

#### Market Data & Revolut Availability

| Tool | Description |
|---|---|
| `get_price` | Real-time stock/ETF price + Revolut availability |
| `get_prices_bulk` | Up to 20 tickers with gainers/losers summary |
| `get_crypto_price` | Live crypto price from Binance with 24h stats |
| `price_snapshot` | Full market snapshot — stocks + crypto + mood |
| `revolut_price_check` | Is this ticker available on Revolut? Price + verdict |
| `crypto_top_movers` | Top gainers & losers by 24h volume (Binance) |
| `get_revolut_tradable_list` | Full list of Revolut stocks or crypto |
| `search_revolut_tradable` | Search Revolut assets by ticker or company name |

#### SEC Insider Trading

| Tool | Description |
|---|---|
| `get_insider_filings` | SEC Form 4 filings with CEO/CFO flag + severity |
| `get_insider_clusters` | Multiple insiders trading same stock same day |
| `get_insider_weekly_summary` | Top tickers by insider trade value this week |
| `cross_reference_insider_revolut` | Insider trades filtered to Revolut-tradable only |

#### Revolut Banking (Open Banking / Revolut X)

| Tool | Description |
|---|---|
| `get_accounts` | List all Revolut accounts |
| `get_account_balance` | Balance for a specific account |
| `get_transactions` | Transaction history with date filtering |
| `get_spending_by_category` | Spending breakdown by merchant category |
| `send_domestic_payment` | Initiate a domestic payment |
| `send_international_payment` | Initiate an international payment |
| `get_exchange_rate` | ECB FX rates via Frankfurter |
| `convert_currency` | Convert amount between any two currencies |
| `get_revolut_fx_fees` | FX fee estimate by Revolut plan |
| `get_multi_currency_balances` | All balances with GBP equivalent |
| `place_crypto_order` | Place market or limit order via Revolut X |
| `get_crypto_ohlc` | OHLC candlestick data from Revolut X |

#### Analytics & Intelligence

| Tool | Description |
|---|---|
| `get_technical_summary` | Price, RSI, support/resistance, signal |
| `get_market_sentiment` | Fear & Greed index |
| `get_sector_performance` | Sector ETF performance comparison |
| `get_dividend_screener` | High-yield dividend stocks on Revolut |
| `get_options_flow` | Unusual options activity for a ticker |
| `get_whale_wallets` | Large crypto wallet movement tracker |
| `get_arbitrage_opportunities` | Price spread between Revolut and Binance |
| `get_tax_loss_harvesting` | Portfolio positions eligible for tax-loss harvest |
| `get_portfolio_rebalance` | Rebalancing suggestions vs target allocations |
| `get_stock_screener` | Filter Revolut stocks by market cap, sector, yield |
| `get_economic_calendar` | Upcoming high-impact macro events |

#### Portfolios, Watchlists & Alerts

| Tool | Description |
|---|---|
| `create_portfolio` / `get_portfolio` / `update_portfolio` | Portfolio CRUD with live valuation |
| `add_to_watchlist` / `get_watchlist` / `remove_from_watchlist` | Per-user ticker watchlists |
| `create_alert` / `list_alerts` / `delete_alert` | Price alert management |
| `register_webhook` | Webhook registration for event notifications |

***

### Built-In MCP Prompts (16)

Pre-written prompt templates that AI assistants can invoke directly:

| Prompt | Purpose |
|---|---|
| `revolut_insider_scan` | Insider filings + price check for a ticker |
| `crypto_market_overview` | Full crypto snapshot with sentiment |
| `portfolio_review` | Portfolio analysis with rebalancing suggestions |
| `revolut_trading_setup` | Availability + price + technical analysis |
| `tax_optimization` | Tax-loss harvesting analysis |
| `dividend_income_strategy` | High-yield stocks on Revolut |
| `crypto_whale_alert` | Whale movements + arbitrage scan |
| `economic_event_prep` | Calendar + sentiment for upcoming events |
| `revolut_vs_competitors` | Revolut vs eToro price comparison |
| `risk_management_check` | Technical + options + sentiment risk check |
| `revolut_banking_overview` | Full account + spending overview |
| `crypto_trading_signals` | Movers + whale data + technicals |
| `etf_sector_rotation` | Identify sector rotation opportunities |
| `insider_trading_opportunities` | Clusters cross-referenced with Revolut |
| `revolut_fee_analysis` | FX fee comparison across plans |
| `stock_screener_query` | Screen stocks by daily performance |

***

### MCP Resources (8)

Access static data directly via MCP resource URIs:

| URI | Contents |
|---|---|
| `revolut://tradable/symbols` | Full list of Revolut-tradable stocks & crypto |
| `revolut://plan-limits` | FX limits and fees by Revolut plan |
| `revolut://tradable/etfs-by-sector` | Sector-grouped ETF catalog |
| `seo://financial-keywords` | High-volume Revolut/finance keywords |
| `seo://blog-post-template` | SEO blog post structure template |
| `seo://top-pages` | Top-priority programmatic SEO pages |
| `market://sector-etfs` | One ETF per market sector |
| `market://crypto-pairs` | Major, DeFi, Layer 2, and meme crypto pairs |

***

### Data Sources

| Source | Data | Latency | API Key |
|---|---|---|---|
| Yahoo Finance | Stocks, ETFs | ~15 min | None |
| Binance | Crypto | Real-time | None |
| SEC EDGAR | Insider Form 4 filings | Live | None |
| Alternative.me | Fear & Greed Index | Live | None |
| Frankfurter (ECB) | FX rates | Daily | None |
| Revolut Open Banking | Accounts, payments | Real-time | OAuth2 cert |
| Revolut X | Crypto trading | Real-time | Ed25519 key |

***

### Configuration

#### Required for HTTP mode

```bash
export PORT=8080
export MCP_TRANSPORT=http
```

#### Revolut Open Banking (optional)

```bash
export REVOLUT_ENV=sandbox          ## or production
export REVOLUT_CLIENT_ID=your_id
export REVOLUT_CERT_PATH=./certs/transport.pem
export REVOLUT_KEY_PATH=./certs/private.key
```

#### Revolut X Crypto Trading (optional)

```bash
export REVOLUT_X_API_KEY=your_key
export REVOLUT_X_PRIVATE_KEY=base64_ed25519_private_key   ## requires pynacl
```

#### Unofficial Personal API — Pockets & Vaults (optional)

```bash
export REVOLUT_DEVICE_ID=your_device_id
export REVOLUT_PHONE_TOKEN=your_bearer_token
```

***

### Deploy to Production

#### Google Cloud Run

```bash
gcloud run deploy revolut-pulse-mcp \
  --source . \
  --platform managed \
  --region europe-west1 \
  --set-env-vars MCP_TRANSPORT=http,PORT=8080 \
  --allow-unauthenticated
```

Health probe hits `GET /ping` → returns `{"status": "ok"}`.

#### Railway

Use the included `railway.json`. Set `MCP_TRANSPORT=http` in environment variables.

#### Fly.io

```bash
fly launch
fly secrets set MCP_TRANSPORT=http PORT=8080
fly deploy
```

***

### SEO & Monetisation

The programmatic SEO engine targets buyers at the bottom of the funnel:

- **"Is \[TICKER] available on Revolut"** — availability + price pages
- **"How to buy \[TICKER] on Revolut"** — step-by-step buying guides
- **"Revolut vs eToro \[TICKER]"** — fee & feature comparison pages
- **"\[TICKER] insider trading activity"** — SEC data pages

Each page auto-generates Schema.org `FinancialProduct` markup and is included in the XML sitemap. Monetise via affiliate links (eToro, Trading 212, Degiro) or premium API tiers.

***

### Security & Reliability

- All market data tools work without any credentials
- Banking tools return clear error messages when unconfigured — they never silently fail
- TTL caching: 10s crypto · 30s stocks · 5min insider data
- Exponential backoff with 3 retry attempts on all outbound calls
- Concurrency limiter: max 5 simultaneous outbound HTTP calls
- Strict regex input validation on all ticker, currency, and account ID inputs
- Structured JSON logging with severity levels

***

### Requirements

```
fastmcp
fastapi
uvicorn
httpx
beautifulsoup4
pynacl        ## optional — only needed for Revolut X signing
```

Python 3.10+

***

### License

MIT — free for personal and commercial use.

***

## Actor input object example

```json
{}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("revolut-pulse/revolut-pulse-mcp-1").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("revolut-pulse/revolut-pulse-mcp-1").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 '{}' |
apify call revolut-pulse/revolut-pulse-mcp-1 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Revolut Pulse Mcp 1",
        "description": "revolut-pulse is a MCP server that gives AI assistants  live access to financial markets, Revolut's tradable asset catalog, and SEC insider trading data — with zero API keys needed for market data.\nIt also ships a programmatic SEO engine that generates hundreds of financial pages targeting queries",
        "version": "0.0",
        "x-build-id": "xkffBEC3WJysYeNGt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/revolut-pulse~revolut-pulse-mcp-1/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-revolut-pulse-revolut-pulse-mcp-1",
                "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/revolut-pulse~revolut-pulse-mcp-1/runs": {
            "post": {
                "operationId": "runs-sync-revolut-pulse-revolut-pulse-mcp-1",
                "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/revolut-pulse~revolut-pulse-mcp-1/run-sync": {
            "post": {
                "operationId": "run-sync-revolut-pulse-revolut-pulse-mcp-1",
                "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": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```