# GMGN Wallet Activity Scraper (`maximedupre/gmgn-wallet-activity-scraper`) Actor

Scrape GMGN.ai wallet activity across Solana, BSC, Ethereum, Base, Tron, and Monad. Export trades, transfers, liquidity activity, token data, prices, amounts, fees, source URLs, and timestamps.

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

## Pricing

from $0.90 / 1,000 wallet activities

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 Wallet Activity Scraper for wallet research

GMGN Wallet Activity Scraper exports public wallet activity from [GMGN.ai](https://gmgn.ai/). Add one or more wallet addresses, choose a chain, pick an activity type, and get clean dataset rows with trades, transfers, liquidity events, token data, amounts, prices, fees, transaction links, GMGN wallet URLs, source URLs, and timestamps.

Use it when you need a repeatable GMGN wallet activity scraper for crypto research, on-chain monitoring, token discovery, wallet due diligence, trading dashboards, or internal alerts. Instead of opening each GMGN wallet page by hand, run the Actor in Apify Console, call it through the Apify API, schedule repeat runs, or export CSV/JSON/Excel files.

For a quick first run, keep the prefilled Solana wallet, leave **Activity type** set to `Trades`, and keep **Maximum activities per wallet** at `25`. That gives you a small sample before you add more wallets, switch chains, include transfers, or collect all supported activity.

### ✅ What this Actor does

- Scrapes public GMGN wallet activity for Solana, BSC, Ethereum, Base, Tron, and Monad.
- Accepts one or more wallet addresses in a single run.
- Lets you collect trades, transfers, liquidity activity, or all supported activity types.
- Supports an optional token address filter.
- Saves one dataset item per successfully scraped wallet activity.
- Includes transaction hash, explorer URL, GMGN wallet URL, source URL, activity type, token data, amounts, price, cost, fees, launchpad fields, and normalized timestamps when GMGN exposes them.
- Runs without your GMGN login, cookies, API key, private wallet data, or wallet connection.

This Actor is focused on the activity feed for submitted wallets. It does not discover GMGN copytrade leaderboard wallets, place trades, send transactions, monitor private account data, or provide financial advice.

### 📦 Data you can extract

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

- `source`, `chain`, `inputWalletAddress`, `walletAddress`, `walletInputIndex`, and `sourceRowNumber` for tracing the row back to your input.
- `activityId`, `transactionHash`, `transactionUrl`, `gmgnWalletUrl`, and `sourceUrl` for review and dedupe.
- `timestamp` and `activityAt` for time-based analysis.
- `eventType`, `activityGroup`, and `side` for grouping trades, transfers, and liquidity activity.
- `token` and `quoteToken` objects with token address, symbol, name, decimals, logo, price, and amount fields when available.
- `tokenAmount`, `quoteAmount`, `costUsd`, `priceUsd`, and `totalUsd` for numeric analysis.
- `fees` with gas, base gas, priority fee, tip, and total fee fields when GMGN exposes them.
- `launchpad`, `scrapeStatus`, and `scrapedAt` for source context and run auditing.

Some GMGN fields are empty for some wallets, chains, tokens, or activity types. When GMGN does not expose a scalar value, the Actor returns `null`.

### 🎯 Common use cases

- Review recent swaps for one or more public wallets.
- Track wallet behavior around a token launch or market event.
- Build datasets for smart money research after you already know which wallets matter.
- Feed transaction hashes, token amounts, prices, and timestamps into dashboards or alerting tools.
- Compare wallet activity across Solana, BSC, Ethereum, Base, Tron, and Monad.
- Schedule recurring exports so your own database keeps a history of visible GMGN activity.

If you first need to discover wallets from GMGN leaderboards, use the GMGN CopyTrade Wallet Scraper linked below. This Actor starts from wallet addresses you already have.

### 🚀 How to scrape GMGN wallet activity

1. Open the Input tab.
2. Add wallet addresses in **Wallet addresses**.
3. Choose one **Blockchain**.
4. Choose **Activity type**:
    - `Trades` for buy and sell activity.
    - `Transfers` for transfer activity.
    - `Liquidity` for add, remove, and burn liquidity activity.
    - `All activity` when you want every supported activity type from the feed.
5. Optional: add a **Token address** to narrow the activity to one token.
6. Set **Maximum activities per wallet**. Keep `25` for a low-cost first run.
7. Start the Actor and open the dataset.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML, or pull the same rows through the Apify API after the run finishes.

### ⚙️ Input example

```json
{
	"walletAddresses": [
		"8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m"
	],
	"chain": "sol",
	"activityMode": "trades",
	"tokenAddress": "",
	"maxActivitiesPerWallet": 25
}
````

`walletAddresses` is the list of public wallets to check. `chain` selects one GMGN chain for the run. `activityMode` controls which activity types are requested. `tokenAddress` is optional. `maxActivitiesPerWallet` caps saved activities for each submitted wallet.

### 🧾 Output example

```json
{
	"source": "gmgn",
	"chain": "sol",
	"inputWalletAddress": "8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m",
	"walletAddress": "8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m",
	"walletInputIndex": 1,
	"sourceRowNumber": 1,
	"activityId": "sol:5sTb...kXy:sell:1754731072",
	"transactionHash": "5sTbz7u2gJu5i4tMfQa6N7zB6e2sNxkYcKxSsjwQgYz3Rr5n47YMSURz4VrVA29Kxfi8z7paVKq56C4cz5Q3PkXy",
	"transactionUrl": "https://solscan.io/tx/5sTbz7u2gJu5i4tMfQa6N7zB6e2sNxkYcKxSsjwQgYz3Rr5n47YMSURz4VrVA29Kxfi8z7paVKq56C4cz5Q3PkXy",
	"gmgnWalletUrl": "https://gmgn.ai/sol/address/8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m",
	"sourceUrl": "https://gmgn.ai/vas/api/v1/wallet_activity/sol?wallet=8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m",
	"timestamp": 1754731072,
	"activityAt": "2025-08-09T09:17:52.000Z",
	"eventType": "sell",
	"activityGroup": "trade",
	"side": "sell",
	"token": {
		"address": "So11111111111111111111111111111111111111112",
		"symbol": "SOL",
		"amount": 0.00943988,
		"priceUsd": 117427.44717094
	},
	"quoteToken": {
		"symbol": "USDC",
		"amount": 1108.50101
	},
	"tokenAmount": 0.00943988,
	"quoteAmount": 1108.50101,
	"costUsd": 1108.50101,
	"priceUsd": 117427.44717094,
	"fees": {
		"gasUsd": 0.0003032833333333
	},
	"launchpad": {
		"name": null,
		"platform": null
	},
	"scrapeStatus": "ok",
	"scrapedAt": "2026-06-12T18:33:00.000Z"
}
```

The full dataset can include more token, quote token, fee, and launchpad fields when GMGN provides them.

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged only for each wallet activity saved to the dataset. Empty wallets, skipped activity, or runs that produce no saved activities do not create paid activity rows.

Pricing starts at `$0.0045` per saved wallet activity on the Free tier and goes down to `$0.0009` per saved wallet activity on higher tiers. Keep **Maximum activities per wallet** low for a first test, then raise it when the output matches your workflow.

### ⚠️ Limits and caveats

- GMGN activity is public source data and can change between runs.
- One run uses one selected chain. Start another run when you want a different chain.
- Some wallets have no recent visible activity for the selected chain, activity type, or token filter.
- Some output fields are activity-specific. For example, fee, launchpad, quote token, or price fields may be `null`.
- The Actor does not connect to wallets, sign messages, send transactions, or trade.
- This data is for research and monitoring. It is not financial advice.

### ❓ FAQ

#### 🔐 Do I need a GMGN login, API key, cookies, or wallet connection?

No. The Actor uses public GMGN wallet activity data and does not ask for GMGN credentials, cookies, API keys, private keys, seed phrases, or a wallet connection.

#### 👛 Can I scrape multiple wallets?

Yes. Add multiple wallet addresses in the input. The Actor saves activities for each wallet up to **Maximum activities per wallet**.

#### 🧭 How is this different from GMGN CopyTrade Wallet Scraper?

GMGN CopyTrade Wallet Scraper discovers wallets from public GMGN leaderboards. GMGN Wallet Activity Scraper starts from wallet addresses you provide and exports their visible activity feed.

#### 🔎 What happens if a wallet has no matching activity?

The run finishes normally. No paid activity row is created for that wallet unless an activity is saved to the dataset.

#### 🛑 Can this Actor place trades or follow a wallet automatically?

No. It only exports public activity data. It does not send transactions, trade, copytrade, or interact with your wallet.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [GMGN CopyTrade Wallet Scraper ↗](https://apify.com/maximedupre/gmgn-copytrade-wallet-scraper) - Export public GMGN smart money leaderboards for crypto wallet research.
- [Arkham Wallet Data ↗](https://apify.com/maximedupre/arkham-intelligence-wallet-data-scraper) - Scrape public Arkham wallet intelligence, balances, history, and portfolio data.
- [Bitget Tickers Scraper ↗](https://apify.com/maximedupre/bitget-tickers-scraper) - Export live Bitget spot and futures market ticker snapshots.
- [Stocktwits Scraper ↗](https://apify.com/maximedupre/stocktwits-scraper) - Scrape public ticker messages and sentiment for market monitoring.
- [Twitter Scraper ↗](https://apify.com/maximedupre/twitter-scraper) - Search public X posts, profiles, and trends for social market research.

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

# Actor input Schema

## `walletAddresses` (type: `array`):

Add one or more wallet addresses from the selected chain.

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

Choose the GMGN chain to scan for every wallet in this run.

## `activityMode` (type: `string`):

Choose the kind of wallet activity to collect.

## `tokenAddress` (type: `string`):

Add a token address to collect activity for one token on the selected chain.

## `maxActivitiesPerWallet` (type: `integer`):

Set how many activity rows to save for each wallet.

## Actor input object example

```json
{
  "walletAddresses": [
    "8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m"
  ],
  "chain": "sol",
  "activityMode": "trades",
  "maxActivitiesPerWallet": 25
}
```

# Actor output Schema

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

Open the dataset to view saved GMGN wallet activity rows.

# 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 = {
    "walletAddresses": [
        "8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/gmgn-wallet-activity-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 = { "walletAddresses": ["8a3rUE9ArYhRJdubwerxRFSN8A1GRPyXCzya6DGUKT2m"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GMGN Wallet Activity Scraper",
        "description": "Scrape GMGN.ai wallet activity across Solana, BSC, Ethereum, Base, Tron, and Monad. Export trades, transfers, liquidity activity, token data, prices, amounts, fees, source URLs, and timestamps.",
        "version": "0.1",
        "x-build-id": "ex1mL4a0QBGhJOlhm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~gmgn-wallet-activity-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-gmgn-wallet-activity-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-wallet-activity-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-gmgn-wallet-activity-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-wallet-activity-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-gmgn-wallet-activity-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": [
                    "walletAddresses",
                    "chain"
                ],
                "properties": {
                    "walletAddresses": {
                        "title": "Wallet addresses",
                        "type": "array",
                        "description": "Add one or more wallet addresses from the selected chain.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "chain": {
                        "title": "Blockchain",
                        "enum": [
                            "sol",
                            "bsc",
                            "eth",
                            "base",
                            "tron",
                            "monad"
                        ],
                        "type": "string",
                        "description": "Choose the GMGN chain to scan for every wallet in this run.",
                        "default": "sol"
                    },
                    "activityMode": {
                        "title": "Activity type",
                        "enum": [
                            "trades",
                            "transfers",
                            "liquidity",
                            "all"
                        ],
                        "type": "string",
                        "description": "Choose the kind of wallet activity to collect.",
                        "default": "trades"
                    },
                    "tokenAddress": {
                        "title": "Token address",
                        "type": "string",
                        "description": "Add a token address to collect activity for one token on the selected chain."
                    },
                    "maxActivitiesPerWallet": {
                        "title": "Activities per wallet",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Set how many activity rows to save for each wallet.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
