# Meetup Events Scraper (`fetch_cat/meetup-events-scraper`) Actor

📅 Extract public Meetup events by keyword, location, group, or event URL. Get dates, venues, organizer names, descriptions, and links.

- **URL**: https://apify.com/fetch\_cat/meetup-events-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 result extracteds

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

## Meetup Events Scraper

Extract public Meetup events from search pages, group pages, and event detail URLs. Use it to monitor community events, conferences, meetups, workshops, webinars, and local networking opportunities by keyword or location.

### What does Meetup Events Scraper do?

Meetup Events Scraper collects public event information from Meetup and saves it into a structured Apify dataset. You can start from Meetup URLs, enter search keywords, add a location, and choose how many events to collect.

The actor is useful when you need event intelligence in a spreadsheet, database, CRM, lead-generation workflow, or market research dashboard.

### Who is it for?

- 📣 Event marketers tracking communities and topics
- 🤝 Community managers monitoring nearby events
- 🧲 Lead-generation teams finding active groups and organizers
- 🧑‍💼 Recruiters mapping meetups by skill or city
- 📊 Market researchers measuring event supply by niche
- 🗓️ Conference scouts finding talks and workshops
- 🧰 Automation builders feeding event data into internal systems

### Why use it?

Manual Meetup research is slow when you need repeatable coverage across many topics or cities. This actor turns public Meetup pages into clean rows with dates, venue data, organizer names, group URLs, and event links.

### What data can it extract?

| Field | Description |
| --- | --- |
| `eventId` | Meetup event ID when visible |
| `eventUrl` | Canonical public event URL |
| `title` | Event title |
| `description` | Public event description |
| `startDate` | Event start date/time |
| `endDate` | Event end date/time |
| `timezone` | Date offset when available |
| `isOnline` | Whether the event is online or mixed |
| `venueName` | Public venue name |
| `address` | Public formatted address |
| `city` | City from public address data |
| `country` | Country from public address data |
| `groupName` | Meetup group or organizer name |
| `groupUrl` | Meetup group URL |
| `organizerName` | Organizer/group name from public event data |
| `imageUrl` | Event image URL |
| `attendanceCount` | Public attendance/capacity when visible |
| `rsvpCount` | Public RSVP count when visible |
| `scrapedAt` | Timestamp when the row was saved |

### How much does it cost to scrape Meetup events?

The actor uses pay-per-event pricing. You pay a small start fee for each run and a per-event fee for events saved to the dataset. Keep `maxItems` low for test runs, then increase it once your input returns the type of events you need.

### Input options

You can provide:

- `startUrls` — Meetup find, group, or event URLs
- `keywords` — search terms such as `data`, `python`, or `startup`
- `location` — optional city or region for keyword searches
- `maxItems` — maximum events to save
- `includeDetails` — enrich rows by opening event detail pages
- `proxyConfiguration` — optional proxy settings

### Quick start

1. Open the actor on Apify.
2. Paste one or more public Meetup URLs or enter keywords.
3. Set `maxItems` to a small number for the first run.
4. Start the actor.
5. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS" }
  ],
  "keywords": ["javascript"],
  "location": "Berlin, Germany",
  "maxItems": 25,
  "includeDetails": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Example output

```json
{
  "eventId": "315065428",
  "eventUrl": "https://www.meetup.com/jug-nurnberg/events/315065428/",
  "title": "Double Feature: Backend-Performance mit Data Engineering & Projekte ruinieren",
  "description": "Hallo liebe Java User Group Mitglieder!...",
  "startDate": "2026-06-18T18:00:00+02:00",
  "endDate": "2026-06-18T21:00:00+02:00",
  "timezone": "+02:00",
  "isOnline": true,
  "venueName": "codecentric Office Nürnberg",
  "address": "Nürnberg, Germany",
  "city": "Nürnberg",
  "country": "Germany",
  "groupName": "Java User Group Nürnberg",
  "groupUrl": "https://www.meetup.com/jug-nurnberg/",
  "organizerName": "Java User Group Nürnberg",
  "imageUrl": "https://secure-content.meetupstatic.com/...jpg",
  "attendanceCount": null,
  "rsvpCount": null,
  "scrapedAt": "2026-06-18T14:00:00.000Z"
}
```

### Supported Meetup URLs

Use public URLs such as:

- Meetup search pages
- Meetup event detail pages
- Meetup group pages that list public events

For best results, use event search URLs or keywords with a location.

### Tips for better results

- 🎯 Use specific keywords like `product management`, `ai`, or `founder`.
- 🌍 Add a location when you need city-level coverage.
- 🧪 Start with `maxItems: 10` to validate your search.
- 📄 Keep `includeDetails` enabled when you need descriptions and venue fields.
- 🔁 Schedule the actor to monitor changing event calendars.

### Common workflows

#### Event lead generation

Search by topic and city, export event URLs and organizer names, then qualify relevant communities for sponsorship or partnership outreach.

#### Recruiting research

Track technical meetups by language, framework, or role. Use titles, dates, and group names to understand active talent communities.

#### Market mapping

Compare event activity across cities or niches by running the actor with multiple keyword/location combinations.

### Integrations

Use the dataset with:

- Google Sheets or Excel exports
- Apify webhooks
- Make or Zapier automations
- CRM imports
- Internal dashboards
- Data warehouses
- Slack alerts for new events

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/meetup-events-scraper').call({
  keywords: ['data'],
  location: 'Berlin, Germany',
  maxItems: 20
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/meetup-events-scraper').call(run_input={
    'keywords': ['data'],
    'location': 'Berlin, Germany',
    'maxItems': 20,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~meetup-events-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["data"],"location":"Berlin, Germany","maxItems":20}'
```

### MCP usage

Connect the actor to Claude Desktop, Claude Code, or other MCP clients through Apify MCP Server:

```text
https://mcp.apify.com/?tools=fetch_cat/meetup-events-scraper
```

Add the actor to Claude Code:

```bash
claude mcp add apify-meetup-events https://mcp.apify.com/?tools=fetch_cat/meetup-events-scraper
```

Example Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-meetup-events": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/meetup-events-scraper"
    }
  }
}
```

Example prompts:

- "Find upcoming AI meetups in Berlin and summarize the most relevant ones."
- "Scrape public Meetup events for startup keywords in New York."
- "Export event titles, dates, venues, and organizer names from this Meetup search URL."

### Scheduling

You can schedule the actor daily, weekly, or monthly to monitor new public Meetup events. Use a small `maxItems` for frequent monitoring and larger runs for periodic market scans.

### Data freshness

The actor reads public Meetup pages at run time. Event availability, dates, and venues may change after your run, so schedule recurring runs if freshness matters.

### Limits

The actor can only extract public information visible without logging in. Private group data, attendee lists behind account flows, messages, and member-only information are not supported.

### Proxy notes

Most small runs should work without a proxy. If your network is blocked, enable Apify Proxy. Start with datacenter proxies before trying residential proxies.

### Legality and ethical use

This actor extracts public event information. Make sure your use complies with applicable laws, Meetup terms, privacy rules, and your organization's data policies. Do not use scraped data for spam or abusive outreach.

### FAQ

#### Is it legal to scrape Meetup events?

The actor is designed for public event information. You are responsible for using the data lawfully, respecting applicable terms, and avoiding spam or abusive outreach.

#### Can it scrape private groups or attendee lists?

No. It only targets public event data visible without logging in. Private groups, member-only fields, messages, and account-only attendee lists are not supported.

### Troubleshooting

#### Why did my run return fewer events than `maxItems`?

The public page may contain fewer matching events, or Meetup may not expose all results in one public page. Try another keyword, broader location, or a public Meetup find URL.

#### Why are RSVP fields empty?

Meetup does not always expose RSVP or attendance counts publicly. The actor leaves those fields empty when the public page does not include them.

#### Should I disable event detail enrichment?

Disable `includeDetails` if you only need titles and URLs and want faster runs. Keep it enabled for fuller descriptions, dates, venues, and organizer fields.

### Related actors

Explore other Anna Apify actors for web research and search workflows:

- https://apify.com/fetch\_cat/google-search-results-scraper
- https://apify.com/fetch\_cat/google-news-scraper
- https://apify.com/fetch\_cat/linkedin-jobs-scraper

### Changelog

#### 0.1

Initial version for public Meetup event search and detail extraction.

### Support

If a public Meetup URL fails or you need a field that appears on the public page, open an issue with the run ID and example URL so we can investigate.

# Actor input Schema

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

Public Meetup find, group, or event URLs to scrape.

## `keywords` (type: `array`):

Search keywords used to build public Meetup event search URLs.

## `location` (type: `string`):

Optional Meetup search location, such as 'Berlin, Germany' or 'New York, NY'.

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

Maximum number of Meetup events to save.

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

Fetch event detail pages to enrich search results with the most complete public fields.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Datacenter proxies are usually sufficient; use residential only if your run is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS"
    }
  ],
  "keywords": [
    "data"
  ],
  "location": "Berlin, Germany",
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS"
        }
    ],
    "keywords": [
        "data"
    ],
    "location": "Berlin, Germany",
    "maxItems": 10,
    "includeDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/meetup-events-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 = {
    "startUrls": [{ "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS" }],
    "keywords": ["data"],
    "location": "Berlin, Germany",
    "maxItems": 10,
    "includeDetails": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/meetup-events-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 '{
  "startUrls": [
    {
      "url": "https://www.meetup.com/find/?keywords=data&source=EVENTS"
    }
  ],
  "keywords": [
    "data"
  ],
  "location": "Berlin, Germany",
  "maxItems": 10,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup Events Scraper",
        "description": "📅 Extract public Meetup events by keyword, location, group, or event URL. Get dates, venues, organizer names, descriptions, and links.",
        "version": "0.1",
        "x-build-id": "Xzn0HQOMbISh5So68"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~meetup-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-meetup-events-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/fetch_cat~meetup-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-meetup-events-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/fetch_cat~meetup-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-meetup-events-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Public Meetup find, group, or event URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search keywords used to build public Meetup event search URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional Meetup search location, such as 'Berlin, Germany' or 'New York, NY'."
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Meetup events to save.",
                        "default": 10
                    },
                    "includeDetails": {
                        "title": "Open event detail pages",
                        "type": "boolean",
                        "description": "Fetch event detail pages to enrich search results with the most complete public fields.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Datacenter proxies are usually sufficient; use residential only if your run is blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```