# Luma Events Scraper — Events, Organizers & Social Handles (`fayoussef/luma-events-scraper`) Actor

Scrape events from Luma (lu.ma / luma.com) by city, calendar, or event URL. Get dates, venues, ticket prices, guest counts, and full organizer profiles with Instagram, LinkedIn, TikTok, X and YouTube handles.

- **URL**: https://apify.com/fayoussef/luma-events-scraper.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does Luma Events Scraper do?

Luma Events Scraper lets you **scrape Luma events data at scale** from [luma.com](https://luma.com) (formerly lu.ma) — the fastest-growing platform for tech, AI, crypto, and startup events. Extract **event names, dates, venues with GPS coordinates, ticket prices, guest counts, full descriptions**, and — the real gold — **organizer profiles with Instagram, LinkedIn, TikTok, X (Twitter), and YouTube handles** for lead generation and sponsorship outreach.

Because it runs on Apify, you can **export data as JSON, CSV, Excel, or HTML**, run it on a **schedule**, call it via **API**, connect it to **integrations** (Google Sheets, Slack, Make, Zapier), and call it from an **AI agent via the Apify MCP server**. No Luma account, cookies, or browser needed — it is a fast, HTTP-only Luma API alternative.

### Why scrape Luma events?

- **Lead generation** — every event lists its hosts with social handles. Build outreach lists of event organizers, community founders, and startup operators in any city.
- **Sponsorship targeting** — find AI meetups, hackathons, and conferences worth sponsoring before your competitors do.
- **Event aggregation** — power a local events website, newsletter, or Discord bot with fresh structured event data.
- **Market research** — measure the tech/AI/crypto meetup scene across cities and track its growth week over week.
- **Competitor monitoring** — watch specific community calendars and get notified about their new events.

### How to scrape Luma events data

1. Open the **Input** tab and enter one or more cities (`nyc`, `sf`, `london`, `dubai`…), calendar URLs, or direct event URLs.
2. Optionally set a category (`ai`, `crypto`, `fitness`…), keyword, or date range.
3. Keep **Fetch full event details** enabled to get descriptions and host social handles.
4. Click **Start** and download your results from the **Dataset** tab as JSON, CSV, Excel, or HTML.
5. Optional: set a **schedule** (e.g. weekly) to keep your event database fresh automatically.

### Input

| Field | Description |
|-------|-------------|
| `cities` | Luma city slugs or URLs to discover events in (e.g. `nyc`, `https://luma.com/sf`) |
| `category` | Optional category filter for city discovery (e.g. `ai`, `crypto`) |
| `calendarUrls` | Community calendar pages to scrape upcoming events from |
| `eventUrls` | Direct event URLs to scrape in full detail |
| `keyword` | Only keep events matching this keyword |
| `dateFrom` / `dateTo` | Date range filter (YYYY-MM-DD) |
| `fetchEventDetails` | Fetch descriptions + host profiles with social handles (recommended) |
| `maxEvents` | Maximum events to scrape |
| `concurrency` | Parallel detail requests (default 20) |

```json
{
    "cities": ["nyc"],
    "category": "ai",
    "fetchEventDetails": true,
    "maxEvents": 100
}
````

### Output

```json
{
    "name": "Matcha Meetup NYC",
    "url": "https://luma.com/4m9phuxk",
    "startAt": "2026-07-04T15:00:00.000Z",
    "endAt": "2026-07-04T17:00:00.000Z",
    "timezone": "America/New_York",
    "location": {
        "venue": "Isshiki Matcha inside ACE Hotel",
        "city": "New York",
        "region": "New York",
        "country": "United States",
        "latitude": 40.7456899,
        "longitude": -73.9881963
    },
    "isFree": false,
    "guestCount": 42,
    "registration": "open",
    "description": "join us for corgi f&f matcha meetup! ...",
    "hosts": [
        {
            "name": "jamie",
            "bio": "Corgi @ NYC",
            "instagram": "jamiejipark",
            "linkedin": "/in/jamie-park16",
            "twitter": "sugarjammi",
            "tiktok": "sugarjammi",
            "youtube": "sugarjammi"
        }
    ],
    "calendarName": "Personal",
    "source": "city:nyc"
}
```

### Data fields

| Field | Description |
|-------|-------------|
| `name`, `url`, `slug` | Event title and link |
| `startAt`, `endAt`, `timezone` | Event schedule (ISO 8601) |
| `location` | Venue, city, region, country, GPS coordinates, online/offline |
| `isFree`, `price`, `isSoldOut`, `spotsRemaining` | Ticket availability and pricing |
| `guestCount`, `registration`, `waitlistActive` | Attendance signals |
| `description` | Full plain-text event description |
| `hosts` | Organizer profiles: name, bio, avatar, Instagram, LinkedIn, TikTok, X, YouTube, website |
| `calendarName`, `calendarSlug`, `calendarWebsite` | Community/calendar the event belongs to |
| `categories` | Luma categories the event is tagged with |

### How much does it cost to scrape Luma?

Scraping is HTTP-only (no browser), so compute usage is minimal — a run of 100 events with full details typically completes in under a minute on the default settings. **Free plan users are limited to 25 events per run.** Subscribe to an [Apify plan](https://apify.com/pricing?fpr=youssef) to unlock full limits and scheduling.

### Tips for best results

- Keep `fetchEventDetails` on — host social handles are only available on detail pages.
- Use `category` + city (e.g. `ai` in `sf`) to target the exact niche you care about.
- Schedule a weekly run with `dateFrom` set to today to maintain a rolling events database.
- Raise `concurrency` up to 50 for large runs.

### Is scraping Luma legal?

This Actor only extracts **publicly available data** — the same information any visitor sees on luma.com. It collects no private data, requires no login, and complies with Apify's terms. You are responsible for using scraped data in accordance with applicable laws (GDPR, CCPA) — especially personal data such as organizer names and social handles.

### FAQ

**Is there a Luma API?**
Luma's official API is limited to your own calendars. This Actor is a Luma API alternative that works on any public city, calendar, or event page.

**Can I use this from an AI agent?**
Yes — call this Actor from any AI agent or LLM workflow via the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). It works great as a tool for agents doing event research or lead generation.

**Does it work for lu.ma links?**
Yes — lu.ma URLs redirect to luma.com and both are supported.

**What if a city or calendar returns nothing?**
Check the slug at https://luma.com/discover. Errors are listed in the run log and the run report.

### Support & custom solutions

Found an issue? Report it on the **Issues** tab and I'll fix it fast.

💼 Need a custom scraper or automation? Reach out at **youssefarhan24@gmail.com**
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)
⚡ [Subscribe to an Apify plan](https://apify.com/pricing?fpr=youssef) to unlock full limits.

# Actor input Schema

## `cities` (type: `array`):

Luma city slugs or city page URLs to discover events in. Examples: `nyc`, `sf`, `london`, `dubai`, or `https://luma.com/nyc`. Find all cities at https://luma.com/discover

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

## `category` (type: `string`):

Optional category to filter city discovery results. Examples: `ai`, `crypto`, `fitness`, `arts`. See https://luma.com/discover for all categories.

## `calendarUrls` (type: `array`):

Luma calendar/community page URLs to scrape upcoming events from. Example: `https://luma.com/ls`

## `eventUrls` (type: `array`):

Direct Luma event URLs or slugs to scrape in full detail. Example: `https://luma.com/4m9phuxk`

## `keyword` (type: `string`):

Only keep events whose name or description contains this keyword (case-insensitive).

## `dateFrom` (type: `string`):

Only include events starting on or after this date (YYYY-MM-DD).

## `dateTo` (type: `string`):

Only include events starting on or before this date (YYYY-MM-DD).

## `fetchEventDetails` (type: `boolean`):

Fetch each event's detail page to include the full description, ticket types, and host profiles with Instagram, LinkedIn, TikTok, X (Twitter) and YouTube handles. Slightly slower but far richer data — this is the lead-generation gold.

## `maxEvents` (type: `integer`):

Maximum number of events to scrape across all sources.

## `concurrency` (type: `integer`):

Number of parallel requests for event detail fetching. Higher = faster. Default 20, max 50.

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

Proxy settings. Residential proxies are used by default for maximum reliability.

## Actor input object example

```json
{
  "cities": [
    "nyc"
  ],
  "category": "ai",
  "fetchEventDetails": true,
  "maxEvents": 100,
  "concurrency": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `events` (type: `string`):

All scraped events. Switch between the Events overview and Organizer leads views in the table.

# 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 = {
    "cities": [
        "nyc"
    ],
    "category": "ai",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/luma-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 = {
    "cities": ["nyc"],
    "category": "ai",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/luma-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 '{
  "cities": [
    "nyc"
  ],
  "category": "ai",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fayoussef/luma-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Luma Events Scraper — Events, Organizers & Social Handles",
        "description": "Scrape events from Luma (lu.ma / luma.com) by city, calendar, or event URL. Get dates, venues, ticket prices, guest counts, and full organizer profiles with Instagram, LinkedIn, TikTok, X and YouTube handles.",
        "version": "0.1",
        "x-build-id": "DSm5UZkpDb4FUXzQ6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~luma-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-luma-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/fayoussef~luma-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-luma-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/fayoussef~luma-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-luma-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": {
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Luma city slugs or city page URLs to discover events in. Examples: `nyc`, `sf`, `london`, `dubai`, or `https://luma.com/nyc`. Find all cities at https://luma.com/discover\n\n⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).\n💼 Need a custom solution? Reach out at youssefarhan24@gmail.com\n🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category filter",
                        "type": "string",
                        "description": "Optional category to filter city discovery results. Examples: `ai`, `crypto`, `fitness`, `arts`. See https://luma.com/discover for all categories."
                    },
                    "calendarUrls": {
                        "title": "Calendar URLs",
                        "type": "array",
                        "description": "Luma calendar/community page URLs to scrape upcoming events from. Example: `https://luma.com/ls`",
                        "items": {
                            "type": "string"
                        }
                    },
                    "eventUrls": {
                        "title": "Event URLs",
                        "type": "array",
                        "description": "Direct Luma event URLs or slugs to scrape in full detail. Example: `https://luma.com/4m9phuxk`",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Only keep events whose name or description contains this keyword (case-insensitive)."
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Only include events starting on or after this date (YYYY-MM-DD)."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Only include events starting on or before this date (YYYY-MM-DD)."
                    },
                    "fetchEventDetails": {
                        "title": "Fetch full event details (hosts + socials)",
                        "type": "boolean",
                        "description": "Fetch each event's detail page to include the full description, ticket types, and host profiles with Instagram, LinkedIn, TikTok, X (Twitter) and YouTube handles. Slightly slower but far richer data — this is the lead-generation gold.",
                        "default": true
                    },
                    "maxEvents": {
                        "title": "Max events",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of events to scrape across all sources.",
                        "default": 100
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of parallel requests for event detail fetching. Higher = faster. Default 20, max 50.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are used by default for maximum reliability.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
