# GoFundMe Campaigns Scraper (`automation-lab/gofundme-campaigns-scraper`) Actor

🔎 Scrape public GoFundMe fundraisers by keyword or URL. Extract campaign titles, organizer, story, amounts, goals, donations, and images.

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

## Pricing

Pay per event

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

## GoFundMe Campaigns Scraper

Extract public fundraiser data from GoFundMe search results and campaign pages. Use keywords, GoFundMe search URLs, or direct fundraiser URLs to collect campaign titles, organizers, locations, amounts raised, goals, donation counts, stories, images, and status fields.

The actor is built for public data collection. It does not log in, donate, message organizers, or access private donor information.

### What does GoFundMe Campaigns Scraper do?

GoFundMe Campaigns Scraper turns public GoFundMe fundraiser pages into structured dataset rows.

It can:

- 🔎 Search GoFundMe by keyword, person, location, cause, or topic
- 🔗 Process direct `https://www.gofundme.com/f/...` campaign URLs
- 📄 Open campaign pages for richer details
- 💰 Extract raised amount, goal, currency, and donation count
- 🧑 Capture organizer and visible beneficiary or charity information
- 🏙️ Capture public location fields when GoFundMe exposes them
- 🖼️ Save fundraiser image URLs
- 📊 Export clean JSON, CSV, Excel, XML, or API results from Apify datasets

### Who is it for?

This scraper is useful for teams that monitor public fundraising activity at scale.

- 📰 Journalists tracking crisis response, disaster relief, or local stories
- 🧑‍💼 Nonprofit analysts monitoring fundraising markets and campaign language
- 🏥 Healthcare researchers studying public medical fundraising patterns
- 🏛️ Public policy teams looking at emergency relief needs
- 📈 Market researchers comparing cause categories and donation momentum
- 🧰 Data teams building dashboards from public campaign metadata

### Why use this scraper?

GoFundMe pages are useful but hard to analyze manually. Search pages are designed for browsing, not for spreadsheet work. This actor converts public fundraiser pages into structured rows so you can sort, filter, deduplicate, and monitor campaigns over time.

### Public data and limitations

The actor only extracts data visible on public GoFundMe pages. Some fields are optional because GoFundMe may hide them, omit them, or expose different fields by country, category, or campaign type.

It does not collect private donor emails, private payment details, private organizer data, or authenticated account-only information.

### How much does it cost to scrape GoFundMe campaigns?

Default pricing is pay-per-result. Formula-derived BRONZE pricing is about $0.1165 per 1,000 saved campaign rows, plus a small run-start event. Actual billing depends on the live Apify pricing configuration shown on the actor page.

For small tests, keep `maxItems` low. For monitoring workflows, raise `maxItems` once you have confirmed the query returns the type of campaigns you want.

### Input options

| Field | Type | Description |
|---|---:|---|
| `searchQueries` | array | Keywords, causes, people, or locations to search on GoFundMe |
| `startUrls` | array | Public GoFundMe search URLs or direct campaign URLs |
| `maxItems` | integer | Maximum campaign records to save across all inputs |
| `includeDetails` | boolean | Visit campaign pages for full story, organizer, image, date, and status fields |

### Example input

```json
{
  "searchQueries": ["medical bills", "flood relief"],
  "startUrls": [
    { "url": "https://www.gofundme.com/f/flood-relief-fund-2025" }
  ],
  "maxItems": 25,
  "includeDetails": true
}
````

### Output data

Each dataset row represents one public GoFundMe fundraiser campaign.

| Field | Description |
|---|---|
| `campaignUrl` | Canonical public fundraiser URL |
| `fundraiserId` | GoFundMe fundraiser ID when visible |
| `slug` | URL slug |
| `title` | Campaign title |
| `organizerName` | Public organizer name |
| `organizerId` | Public organizer ID when visible |
| `beneficiaryName` | Visible beneficiary name, if present |
| `charityName` | Visible charity name, if present |
| `categoryId` | GoFundMe category ID when exposed |
| `city`, `state`, `countryCode` | Public location fields |
| `amountRaised` | Amount raised as a number |
| `goalAmount` | Goal as a number |
| `currency` | Currency code such as `USD` |
| `donationCount` | Number of donations shown by GoFundMe |
| `story` | Plain-text campaign story |
| `imageUrls` | Public image URLs |
| `status` | Campaign status when visible |
| `createdAt`, `publishedAt`, `updatedAt` | Public date fields when visible |
| `sourceQuery`, `sourceUrl` | Input source tracking |

### Example output

```json
{
  "campaignUrl": "https://www.gofundme.com/f/flood-relief-fund-2025",
  "fundraiserId": "92508227",
  "title": "2025 Flood Relief Fund",
  "organizerName": "GoFundMe Org",
  "amountRaised": 678255,
  "goalAmount": 1000000,
  "currency": "USD",
  "donationCount": 3173,
  "city": "Los Angeles",
  "state": "CA",
  "countryCode": "US",
  "status": "ACTIVE"
}
```

### How to scrape GoFundMe by keyword

1. Open the actor on Apify.
2. Add one or more phrases to `searchQueries`.
3. Set `maxItems` to the number of fundraiser rows you need.
4. Keep `includeDetails` enabled if you need stories, images, organizers, or dates.
5. Click **Start**.
6. Download the dataset as CSV, JSON, Excel, or connect through the Apify API.

### How to scrape direct fundraiser URLs

Paste public campaign URLs into `startUrls`, for example:

```json
{
  "startUrls": [
    { "url": "https://www.gofundme.com/f/flood-relief-fund-2025" }
  ],
  "maxItems": 1,
  "includeDetails": true
}
```

This is best when you already have a list of fundraiser pages and want consistent campaign details.

### Tips for better results

- Use specific phrases such as `wildfire relief california` instead of only `help`.
- Run separate queries for separate research topics so `sourceQuery` stays useful.
- Use direct URLs when you need exact known campaigns.
- Disable `includeDetails` only when you need faster search metadata and do not need the full story.
- Deduplicate by `campaignUrl` or `fundraiserId` in your downstream database.

### Integrations

You can connect the dataset to:

- Google Sheets or Excel reporting workflows
- BI dashboards for donation and category trends
- Data warehouses for longitudinal monitoring
- Newsroom research notebooks
- Nonprofit CRM enrichment workflows using only public campaign context
- Alerting pipelines that watch for new campaigns matching a cause or location

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/gofundme-campaigns-scraper').call({
  searchQueries: ['medical bills'],
  maxItems: 25,
  includeDetails: true,
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/gofundme-campaigns-scraper').call(run_input={
    'searchQueries': ['flood relief'],
    'maxItems': 25,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~gofundme-campaigns-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["medical bills"],"maxItems":25,"includeDetails":true}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP:

```text
https://mcp.apify.com/?tools=automation-lab/gofundme-campaigns-scraper
```

Claude Code setup:

```bash
claude mcp add apify-gofundme https://mcp.apify.com/?tools=automation-lab/gofundme-campaigns-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-gofundme": {
      "url": "https://mcp.apify.com/?tools=automation-lab/gofundme-campaigns-scraper"
    }
  }
}
```

Example prompts:

- "Run the GoFundMe Campaigns Scraper for flood relief campaigns and summarize the top campaigns by amount raised."
- "Scrape these GoFundMe URLs and return a CSV with organizer, goal, raised amount, and story."
- "Find public medical fundraiser campaigns matching this query and group them by state."

### Data quality notes

GoFundMe can change field availability by page, country, campaign state, or experiment. The actor keeps optional fields nullable rather than inventing values. Numeric amount fields are returned as numbers when GoFundMe exposes clean numeric values.

### Legality and responsible use

This actor is designed for publicly available GoFundMe pages. You are responsible for using the data legally and ethically. Respect privacy, platform terms, copyright, and applicable data protection rules. Avoid contacting organizers in ways that could be spammy, harmful, or misleading.

### Troubleshooting

If a query returns too few results, try broader terms, remove punctuation, or use a GoFundMe search URL from your browser.

If story or organizer fields are empty, keep `includeDetails` enabled and verify that the public campaign page shows those fields.

If a campaign URL is skipped, confirm it follows the public `/f/<slug>` format and is not a private, deleted, or redirected page.

### FAQ

#### Can it scrape donor names?

No. This actor focuses on campaign-level public fundraiser metadata, not private donor details.

#### Does it need proxies?

The first version uses normal HTTP requests and does not require a residential proxy.

#### Can I monitor the same query every day?

Yes. Schedule the actor on Apify and deduplicate by `campaignUrl` or `fundraiserId` in your destination.

#### Can I scrape a whole category?

Use category-related keywords or GoFundMe search URLs. Category labels may not always be exposed as human-readable names, so the actor currently returns `categoryId` when visible.

### Related scrapers

Other Automation Lab actors that can complement this workflow:

- https://apify.com/automation-lab/google-news-scraper
- https://apify.com/automation-lab/google-search-scraper
- https://apify.com/automation-lab/facebook-ads-library-scraper
- https://apify.com/automation-lab/reddit-scraper

### Changelog

- Initial version: search public GoFundMe campaigns and scrape campaign details.

### Support

If you need a field that appears publicly on GoFundMe but is missing from the dataset, open an issue on Apify with a sample public URL and expected field name.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords, names, causes, cities, or topics to search on GoFundMe.

## `startUrls` (type: `array`):

Public GoFundMe search URLs (for example /s?q=medical) or campaign URLs (/f/campaign-slug).

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

Maximum number of fundraiser records to save across all queries and URLs.

## `includeDetails` (type: `boolean`):

When enabled, the actor opens each fundraiser page to collect organizer, story, image, status, and date fields. Disable for faster search-only results.

## Actor input object example

```json
{
  "searchQueries": [
    "medical bills",
    "flood relief"
  ],
  "startUrls": [
    {
      "url": "https://www.gofundme.com/f/flood-relief-fund-2025"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "medical bills",
        "flood relief"
    ],
    "startUrls": [
        {
            "url": "https://www.gofundme.com/f/flood-relief-fund-2025"
        }
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/gofundme-campaigns-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 = {
    "searchQueries": [
        "medical bills",
        "flood relief",
    ],
    "startUrls": [{ "url": "https://www.gofundme.com/f/flood-relief-fund-2025" }],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/gofundme-campaigns-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 '{
  "searchQueries": [
    "medical bills",
    "flood relief"
  ],
  "startUrls": [
    {
      "url": "https://www.gofundme.com/f/flood-relief-fund-2025"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/gofundme-campaigns-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GoFundMe Campaigns Scraper",
        "description": "🔎 Scrape public GoFundMe fundraisers by keyword or URL. Extract campaign titles, organizer, story, amounts, goals, donations, and images.",
        "version": "0.1",
        "x-build-id": "FOh7CmWlqauvoR7GN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~gofundme-campaigns-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-gofundme-campaigns-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~gofundme-campaigns-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-gofundme-campaigns-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~gofundme-campaigns-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-gofundme-campaigns-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords, names, causes, cities, or topics to search on GoFundMe.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "GoFundMe start URLs",
                        "type": "array",
                        "description": "Public GoFundMe search URLs (for example /s?q=medical) or campaign URLs (/f/campaign-slug).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum campaigns",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of fundraiser records to save across all queries and URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Visit campaign pages for details",
                        "type": "boolean",
                        "description": "When enabled, the actor opens each fundraiser page to collect organizer, story, image, status, and date fields. Disable for faster search-only results.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
