# GMGN CopyTrade Wallet Scraper (`maximedupre/gmgn-copytrade-wallet-scraper`) Actor

Scrape GMGN.ai copytrade wallet leaderboards across Solana, BSC, Ethereum, Base, Tron, and Monad. Export wallet PnL, win rates, transactions, balances, tags, source ranks, and GMGN wallet URLs.

- **URL**: https://apify.com/maximedupre/gmgn-copytrade-wallet-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 gmgn wallets

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

### 🧭 GMGN CopyTrade Wallet Scraper for smart money research

GMGN CopyTrade Wallet Scraper extracts public copytrade wallet leaderboards from [GMGN.ai](https://gmgn.ai/). Choose a chain, trader category, ranking metric, and wallet limit, then get a clean dataset with wallet addresses, PnL, realized profit, win rates, trading activity, balances, tags, profile metadata, source ranks, GMGN wallet URLs, and scrape timestamps.

Use it when you want a repeatable GMGN wallet scraper for smart money research, crypto wallet leaderboard exports, copy trading analysis, alpha sourcing, or recurring wallet monitoring. Instead of checking GMGN leaderboards by hand, you can run the Actor in Apify Console, call it through the Apify API, schedule repeat runs, export CSV/JSON/Excel files, or connect it to webhooks and integrations.

For a small first run, keep the default Solana Smart Money leaderboard, leave the wallet limit at `25`, and start the Actor. Once the output looks right, switch chains, categories, sort fields, or 7-day filters for your own research workflow.

### ✅ What this Actor does

- Scrapes GMGN copytrade wallet leaderboards for Solana, BSC, Ethereum, Base, Tron, and Monad.
- Supports GMGN wallet categories including All wallets, Smart Money, Pump Smart Money, Launchpad Smart Money, KOL / VC, Fresh Wallet, Sniper, Top Tracked, Top Renamed, Top Dev, and LIVE.
- Sorts wallets by profit, PnL, win rate, transactions, volume, net inflow, last active time, balance, tracked count, or renamed count.
- Lets you cap saved wallets with `maxWallets`, so first runs stay small and larger exports stay predictable.
- Adds optional 7-day filters for realized profit, win rate, and transaction count.
- Saves one dataset item per successfully scraped GMGN wallet.
- Includes source rank, source URL, GMGN wallet URL, normalized timestamps, profile fields, tags, PnL buckets, and 7-day daily profit when GMGN exposes them.

This Actor is focused on GMGN leaderboard discovery. It does not deep-scrape a submitted wallet portfolio, token holdings, live buy-signal feeds, token holder lists, or rugcheck data.

### 📦 Data you can extract

Each output item represents one GMGN copytrade wallet. Fields include:

- `walletAddress`, `chain`, `sourceRank`, `sourceUrl`, and `gmgnWalletUrl`
- `traderType`, `traderTypeLabel`, `sourceSortBy`, and `sourceSortDirection`
- `lastActiveTimestamp` and `lastActiveAt`
- `realizedProfit1d`, `realizedProfit7d`, and `realizedProfit30d`
- `pnl1d`, `pnl7d`, `pnl30d`, `winRate1d`, `winRate7d`, and `winRate30d`
- `transactions`, `buys`, and `sells` for total, 1-day, 7-day, and 30-day periods
- `balance`, `ethBalance`, `solBalance`, `trxBalance`, `bnbBalance`, and `monadBalance`
- `volume1d`, `volume7d`, `volume30d`, `netInflow1d`, `netInflow7d`, and `netInflow30d`
- `tags`, `profile`, `dailyProfit7d`, `pnlBuckets7d`, `scrapeStatus`, and `scrapedAt`

Some GMGN fields are empty for some wallets. When GMGN does not expose a value, the Actor returns `null` for scalar fields and empty arrays for lists.

### 🚀 How to run

1. Choose a **Blockchain**.
2. Choose a **Trader category**.
3. Keep **Wallet limit** at `25` for a quick test, or raise it for a larger export.
4. Pick the ranking metric in **Sort by** and choose the sort direction.
5. Optional: add 7-day filters for profit, win rate, or transaction count.
6. Run the Actor and open the dataset.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML. You can also schedule runs to monitor a GMGN leaderboard over time or use the Apify API to pull fresh wallet rows into your own app.

### ⚙️ Input options

```json
{
	"chain": "sol",
	"traderType": "smart_degen",
	"maxWallets": 25,
	"sortBy": "profit_7d",
	"sortDirection": "desc",
	"minProfit7d": 5000,
	"minWinRate7d": 40,
	"minTxs7d": 10
}
````

`chain` selects the GMGN blockchain leaderboard. `traderType` selects the wallet group. `maxWallets` controls how many wallet rows are saved. `sortBy` and `sortDirection` control the leaderboard order. The optional 7-day filters help you keep only wallets that match your minimum profit, win rate, or activity threshold.

### 🧾 Output example

```json
{
	"walletAddress": "mDR91ufq4S2uSHa9E2PYL7xg4LwcQXaQFP7YK864a1z",
	"chain": "sol",
	"sourceRank": 1,
	"traderType": "smart_degen",
	"traderTypeLabel": "Smart Money",
	"sourceSortBy": "profit_7d",
	"sourceSortDirection": "desc",
	"gmgnWalletUrl": "https://gmgn.ai/sol/address/mDR91ufq4S2uSHa9E2PYL7xg4LwcQXaQFP7YK864a1z",
	"lastActiveAt": "2026-05-28T14:10:49.000Z",
	"realizedProfit7d": 33461.114797366354,
	"pnl7d": 0.3277785183031044,
	"winRate7d": 0.6578947368421053,
	"transactions7d": 300,
	"buys7d": 216,
	"sells7d": 84,
	"tags": ["smart_degen", "fomo"],
	"profile": {
		"twitterUsername": null,
		"twitterName": null,
		"nickname": null
	},
	"scrapeStatus": "ok",
	"scrapedAt": "2026-05-28T14:58:27.229Z"
}
```

The exact wallet data changes as GMGN updates its leaderboards.

### 💳 Pricing

This Actor uses pay-per-event pricing. You pay for each GMGN wallet saved by the Actor. Keep the wallet limit small for a test run, then increase it when you are ready to export more leaderboard rows.

### ⚠️ Limits and caveats

GMGN leaderboard data changes often, especially for active wallets and short time windows. Treat each run as a snapshot of the public GMGN leaderboard at the time the Actor ran.

The Actor only returns data exposed by the public GMGN leaderboard response. It does not require your GMGN account, cookies, wallet connection, private API key, or login details. It also does not create trading signals, financial advice, or investment recommendations.

### ❓ FAQ

#### 🧾 Does this scrape a specific wallet portfolio?

No. This Actor scrapes GMGN copytrade wallet leaderboards. It does not accept wallet addresses as targets or return a full token-by-token portfolio for a submitted wallet.

#### 📅 Can I use it for recurring smart money monitoring?

Yes. Schedule the Actor on Apify and compare exported wallet rows over time. Each row includes `sourceRank`, `sourceUrl`, `gmgnWalletUrl`, and `scrapedAt` to make snapshots easier to trace.

#### 🔐 Do I need GMGN cookies or an API key?

No. The Actor is built for public GMGN leaderboard data and does not ask you for GMGN credentials.

#### 📭 Why are some fields empty?

GMGN does not expose every field for every wallet. Empty scalar values are returned as `null`, and missing lists are returned as empty arrays.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~gmgn-copytrade-wallet-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Social Media Stats Checker ↗](https://apify.com/maximedupre/social-media-stats-checker) - Check public creator and brand profile stats across major social platforms.
- [Telegram Channel Messages Scraper ↗](https://apify.com/maximedupre/telegram-channel-messages-scraper) - Export public Telegram channel messages for monitoring and research.
- [Telegram Info Scraper ↗](https://apify.com/maximedupre/telegram-info-scraper) - Get public Telegram channel and group metadata.
- [Twitter (X) Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Scrape public X/Twitter search and social data for market monitoring.
- [Ubersuggest Scraper ↗](https://apify.com/maximedupre/ubersuggest-scraper) - Collect SEO metrics, backlinks, and keyword ideas for market research.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `chain` (type: `string`):

Choose the GMGN chain leaderboard to scrape.

## `traderType` (type: `string`):

Choose the GMGN wallet group. Use All wallets for the broad leaderboard, or choose a smart-money category for a narrower copytrade wallet list.

## `maxWallets` (type: `integer`):

Maximum number of GMGN wallets to save. Start with 25 for a quick test, then raise it for larger leaderboard exports.

## `sortBy` (type: `string`):

Metric used to rank the GMGN wallet leaderboard.

## `sortDirection` (type: `string`):

Use descending for top wallets by the selected metric, or ascending for the lowest values.

## `minProfit7d` (type: `number`):

Keep only wallets with at least this realized 7-day profit in USD. Leave empty to skip this filter.

## `minWinRate7d` (type: `number`):

Keep only wallets with at least this 7-day win rate. Use 40 for 40%. Leave empty to skip this filter.

## `minTxs7d` (type: `integer`):

Keep only wallets with at least this many 7-day transactions. Leave empty to skip this filter.

## Actor input object example

```json
{
  "chain": "sol",
  "traderType": "smart_degen",
  "maxWallets": 25,
  "sortBy": "profit_7d",
  "sortDirection": "desc"
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset to view scraped GMGN wallet leaderboard data.

# 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("maximedupre/gmgn-copytrade-wallet-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/gmgn-copytrade-wallet-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 '{}' |
apify call maximedupre/gmgn-copytrade-wallet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GMGN CopyTrade Wallet Scraper",
        "description": "Scrape GMGN.ai copytrade wallet leaderboards across Solana, BSC, Ethereum, Base, Tron, and Monad. Export wallet PnL, win rates, transactions, balances, tags, source ranks, and GMGN wallet URLs.",
        "version": "0.1",
        "x-build-id": "grtkBtaDqc30caSet"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~gmgn-copytrade-wallet-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-gmgn-copytrade-wallet-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/maximedupre~gmgn-copytrade-wallet-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-gmgn-copytrade-wallet-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/maximedupre~gmgn-copytrade-wallet-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-gmgn-copytrade-wallet-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": [
                    "chain",
                    "traderType"
                ],
                "properties": {
                    "chain": {
                        "title": "Blockchain",
                        "enum": [
                            "sol",
                            "bsc",
                            "eth",
                            "base",
                            "tron",
                            "monad"
                        ],
                        "type": "string",
                        "description": "Choose the GMGN chain leaderboard to scrape.",
                        "default": "sol"
                    },
                    "traderType": {
                        "title": "Trader category",
                        "enum": [
                            "all",
                            "smart_degen",
                            "pump_smart",
                            "launchpad_smart",
                            "kol",
                            "fresh_wallet",
                            "sniper",
                            "top_tracked",
                            "top_renamed",
                            "top_dev",
                            "live"
                        ],
                        "type": "string",
                        "description": "Choose the GMGN wallet group. Use All wallets for the broad leaderboard, or choose a smart-money category for a narrower copytrade wallet list.",
                        "default": "smart_degen"
                    },
                    "maxWallets": {
                        "title": "Wallet limit",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of GMGN wallets to save. Start with 25 for a quick test, then raise it for larger leaderboard exports.",
                        "default": 25
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "profit_1d",
                            "profit_7d",
                            "profit_30d",
                            "pnl_1d",
                            "pnl_7d",
                            "pnl_30d",
                            "winrate_1d",
                            "winrate_7d",
                            "winrate_30d",
                            "txs_1d",
                            "txs_7d",
                            "txs_30d",
                            "volume_1d",
                            "volume_7d",
                            "volume_30d",
                            "net_inflow_1d",
                            "net_inflow_7d",
                            "net_inflow_30d",
                            "last_active",
                            "balance",
                            "tracked",
                            "renamed"
                        ],
                        "type": "string",
                        "description": "Metric used to rank the GMGN wallet leaderboard.",
                        "default": "profit_7d"
                    },
                    "sortDirection": {
                        "title": "Sort direction",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Use descending for top wallets by the selected metric, or ascending for the lowest values.",
                        "default": "desc"
                    },
                    "minProfit7d": {
                        "title": "Minimum 7D profit USD",
                        "type": "number",
                        "description": "Keep only wallets with at least this realized 7-day profit in USD. Leave empty to skip this filter."
                    },
                    "minWinRate7d": {
                        "title": "Minimum 7D win rate %",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Keep only wallets with at least this 7-day win rate. Use 40 for 40%. Leave empty to skip this filter."
                    },
                    "minTxs7d": {
                        "title": "Minimum 7D transactions",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only wallets with at least this many 7-day transactions. Leave empty to skip this filter."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
