# Meetup Scraper - Events, RSVPs & Organizer Leads (`logiover/meetup-scraper`) Actor

Meetup events & organizer leads scraper, no login or API key. A Meetup API alternative: export events to CSV/JSON with RSVP, venue, price and group data.

- **URL**: https://apify.com/logiover/meetup-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper

Scrape Meetup.com events, RSVPs and group organizers from any keyword + city or `/find/` search URL. This Meetup events scraper (also a Meetup group scraper and event-organizer lead extractor) reads Meetup's own public event data, so you get every field with no login and no API key, and export it to CSV, JSON or Excel.

It is two tools in one: an **events dataset** for market research, calendars and dashboards, and an **organizer lead engine** — every event carries its group, member count and organizer name, so one run becomes a targeted outreach list of active community builders.

### What you get

One clean row per Meetup event, with these fields:

- **Event** — `id`, `title`, `eventUrl`, `dateTime` (start), `endTime`, `eventType` (physical/online), `isOnline`, `rsvpState`, `goingCount` (RSVP / attendees), `maxTickets`, `imageUrl`, `description`
- **Price** — `isFree`, `priceAmount`, `priceCurrency`, `paymentMethod`
- **Venue & geo** — `venueName`, `venueAddress`, `venueCity`, `venueState`, `venueCountry`, `venuePostalCode`, `latitude`, `longitude`
- **Group & organizer leads** — `groupName`, `groupUrl`, `groupUrlname`, `groupCity`, `groupState`, `groupCountry`, `groupTimezone`, `groupMemberCount`, `organizerName`, `organizerUrl`
- `scrapedAt` — ISO timestamp of extraction

Export every row as **CSV, JSON or Excel** (also HTML / API) — straight into your CRM, spreadsheet, BI tool or data pipeline.

### Use cases

- **Event-organizer lead gen** — build outreach lists of active community organizers by topic and city, complete with group URL and member count.
- **Market & community research** — track which topics, cities and groups are growing, and at what price.
- **Event aggregators & calendars** — power a niche events site or newsletter from a scheduled run.
- **Sponsorship & partnerships** — find groups with the right size and audience to sponsor.
- **Competitive analysis** — monitor rival meetups, attendance and pricing over time.

### How to use

1. Open the actor and either type a **keyword + location**, or set your search on [meetup.com/find](https://www.meetup.com/find/) and paste the address-bar URL into `searchUrls`.
2. Set `maxResults` (use `0` for no limit) and pick a `sort` order.
3. Click **Start**. When the run finishes, open the **Output / Dataset** tab and export to CSV, JSON or Excel.

Keyword + city:

```json
{
  "keyword": "startup",
  "location": "New York",
  "maxResults": 200
}
````

Multiple cities / topics from copied search URLs:

```json
{
  "searchUrls": [
    "https://www.meetup.com/find/?keywords=web3&location=us--ca--San%20Francisco&source=EVENTS",
    "https://www.meetup.com/find/?keywords=yoga&location=gb--London&source=EVENTS"
  ],
  "maxResults": 2000,
  "sort": "DATETIME"
}
```

#### Input fields

| Field | What it does |
|---|---|
| `searchUrls` | Meetup `/find/` URLs copied from the site. `keywords` and `location` in each URL are read automatically. |
| `keyword` | A topic to search (e.g. `startup`, `yoga`, `web3`). Use with `location`. |
| `location` | City / place to search near (e.g. `New York`, `London`). Geocoded automatically. |
| `sort` | `RELEVANCE`, `DATETIME` (soonest first) or `DISTANCE` (nearest first). |
| `maxResults` | Global cap across all searches. `0` = no limit. |
| `maxResultsPerSearch` | Per-search cap. `0` = no cap. |
| `useProxy` / `proxyConfiguration` | Apify Proxy — residential recommended (default). |
| `maxConcurrency` | How many searches to run in parallel. |

#### Example output

```json
{
  "id": "314505584",
  "title": "Tech Startups, Investors & Founders Networking",
  "eventUrl": "https://www.meetup.com/startup-pitch-and-networking/events/314505584/",
  "dateTime": "2026-06-11T18:00:00-04:00",
  "endTime": "2026-06-11T21:00:00-04:00",
  "eventType": "PHYSICAL",
  "isOnline": false,
  "goingCount": 10,
  "isFree": false,
  "priceAmount": 30,
  "priceCurrency": "USD",
  "venueName": "Bar Nine",
  "venueCity": "New York",
  "venueState": "NY",
  "venueCountry": "us",
  "latitude": 40.7326,
  "longitude": -73.98501,
  "groupName": "Startup Pitch & Networking",
  "groupUrl": "https://www.meetup.com/startup-pitch-and-networking/",
  "groupMemberCount": 1977,
  "organizerName": "Scott Johnson",
  "organizerUrl": "https://www.meetup.com/members/...",
  "imageUrl": "https://secure.meetupstatic.com/photos/event/.../highres.jpeg",
  "description": "Join founders, investors and operators ...",
  "scrapedAt": "2026-06-05T12:00:00.000Z"
}
```

### FAQ

#### Do I need a Meetup account or API key?

No. The actor reads Meetup's own public event data — no login, no API key, no Meetup Pro subscription required.

#### How do I scrape a specific city or topic?

Either type a `keyword` + `location` (e.g. `"web3"` + `"Berlin"`), or go to [meetup.com/find](https://www.meetup.com/find/), run your search, and paste the address-bar URL into `searchUrls`. You can mix many URLs in one run.

#### Does it get the RSVP / attendee count?

Yes. Every event includes its `goingCount` (people going), plus the group's total `groupMemberCount`.

#### Does it include online events and event price?

Yes. Each row has an `isOnline` flag and an `eventType`, plus `isFree`, `priceAmount` and `priceCurrency` for paid events, so you can filter either way.

#### Is this a Meetup API alternative?

Yes. It reads Meetup.com's own public event data with no login and no API key, so it works as a Meetup API alternative when you just need structured event and group data out.

#### How do I export Meetup events to CSV or JSON?

Run a search, then open the Output / Dataset tab and download the results as CSV, JSON or Excel. This makes Meetup data export to a spreadsheet, CRM or pipeline a one-click step.

#### Can I scrape Meetup without login to get organizer leads?

Yes. The scraper pulls events without any account, and each row carries `groupName`, `groupMemberCount`, `organizerName` and `organizerUrl` so one run doubles as a Meetup organizer leads list.

### Changelog

#### 2026-06-07

- Docs: added coverage for Meetup API alternative, Meetup events to CSV/JSON export, and scraping Meetup organizer leads without login.

***

**Meetup scraper · Meetup API alternative · Meetup events to CSV · Meetup data export · Meetup organizer leads scraper · scrape Meetup without login**

# Actor input Schema

## `searchUrls` (type: `array`):

Meetup.com search URLs copied straight from the site — e.g. https://www.meetup.com/find/?keywords=startup\&location=us--ny--New%20York\&source=EVENTS . The keyword and location are read from each URL. Set your search on meetup.com/find, then paste the address-bar URL here. You can also just use the Keyword + Location fields below instead.

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

A topic / keyword to search events for (e.g. "startup", "yoga", "web3", "hiking"). Used together with Location. Leave blank to auto-search a set of broad topics (networking, social, tech, business, music, art, food, fitness, community) near the location — approximating "all events nearby". For best volume, run several specific keywords.

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

City or place to search near (e.g. "New York", "London", "San Francisco", "Berlin"). Geocoded automatically by Meetup. Used together with Keyword.

## `sort` (type: `string`):

Order of the events returned by each search.

## `maxResults` (type: `integer`):

Stop after this many events across all searches. 0 = no limit.

## `maxResultsPerSearch` (type: `integer`):

Cap events per individual search URL / keyword. 0 = no per-search cap.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy. Residential is recommended and is the default.

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

Apify Proxy settings. Residential gives the highest success rate.

## `maxConcurrency` (type: `integer`):

How many searches to process in parallel.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.meetup.com/find/?keywords=startup&location=us--ny--New%20York&source=EVENTS"
  ],
  "keyword": "startup",
  "location": "New York",
  "sort": "RELEVANCE",
  "maxResults": 200,
  "maxResultsPerSearch": 0,
  "useProxy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 3
}
```

# Actor output Schema

## `id` (type: `string`):

Event ID

## `title` (type: `string`):

Event title

## `eventUrl` (type: `string`):

Event URL

## `dateTime` (type: `string`):

Start date/time

## `endTime` (type: `string`):

End date/time

## `eventType` (type: `string`):

Event type

## `isOnline` (type: `string`):

Online event

## `rsvpState` (type: `string`):

RSVP state

## `goingCount` (type: `string`):

Going / RSVP count

## `maxTickets` (type: `string`):

Max tickets

## `isFree` (type: `string`):

Free event

## `priceAmount` (type: `string`):

Price

## `priceCurrency` (type: `string`):

Currency

## `paymentMethod` (type: `string`):

Payment method

## `venueName` (type: `string`):

Venue name

## `venueAddress` (type: `string`):

Venue address

## `venueCity` (type: `string`):

City

## `venueState` (type: `string`):

State

## `venueCountry` (type: `string`):

Country

## `venuePostalCode` (type: `string`):

Postal code

## `latitude` (type: `string`):

Latitude

## `longitude` (type: `string`):

Longitude

## `groupName` (type: `string`):

Group name

## `groupUrlname` (type: `string`):

Group url slug

## `groupUrl` (type: `string`):

Group URL

## `groupCity` (type: `string`):

Group city

## `groupState` (type: `string`):

Group state

## `groupCountry` (type: `string`):

Group country

## `groupTimezone` (type: `string`):

Group timezone

## `groupMemberCount` (type: `string`):

Group member count

## `organizerName` (type: `string`):

Organizer name

## `organizerUrl` (type: `string`):

Organizer profile URL

## `imageUrl` (type: `string`):

Event image URL

## `description` (type: `string`):

Description

## `scrapedAt` (type: `string`):

Scraped at

# 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 = {
    "searchUrls": [
        "https://www.meetup.com/find/?keywords=startup&location=us--ny--New%20York&source=EVENTS"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/meetup-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 = { "searchUrls": ["https://www.meetup.com/find/?keywords=startup&location=us--ny--New%20York&source=EVENTS"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/meetup-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 '{
  "searchUrls": [
    "https://www.meetup.com/find/?keywords=startup&location=us--ny--New%20York&source=EVENTS"
  ]
}' |
apify call logiover/meetup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup Scraper - Events, RSVPs & Organizer Leads",
        "description": "Meetup events & organizer leads scraper, no login or API key. A Meetup API alternative: export events to CSV/JSON with RSVP, venue, price and group data.",
        "version": "1.0",
        "x-build-id": "G9Lfh2AtQX1fiIIwh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~meetup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-meetup-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/logiover~meetup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-meetup-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/logiover~meetup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-meetup-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": {
                    "searchUrls": {
                        "title": "Meetup find URLs",
                        "type": "array",
                        "description": "Meetup.com search URLs copied straight from the site — e.g. https://www.meetup.com/find/?keywords=startup&location=us--ny--New%20York&source=EVENTS . The keyword and location are read from each URL. Set your search on meetup.com/find, then paste the address-bar URL here. You can also just use the Keyword + Location fields below instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "A topic / keyword to search events for (e.g. \"startup\", \"yoga\", \"web3\", \"hiking\"). Used together with Location. Leave blank to auto-search a set of broad topics (networking, social, tech, business, music, art, food, fitness, community) near the location — approximating \"all events nearby\". For best volume, run several specific keywords."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or place to search near (e.g. \"New York\", \"London\", \"San Francisco\", \"Berlin\"). Geocoded automatically by Meetup. Used together with Keyword."
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "RELEVANCE",
                            "DATETIME",
                            "DISTANCE"
                        ],
                        "type": "string",
                        "description": "Order of the events returned by each search.",
                        "default": "RELEVANCE"
                    },
                    "maxResults": {
                        "title": "Max results (total)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many events across all searches. 0 = no limit.",
                        "default": 200
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap events per individual search URL / keyword. 0 = no per-search cap.",
                        "default": 0
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy. Residential is recommended and is the default.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy settings. Residential gives the highest success rate.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent searches",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many searches to process in parallel.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```