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

This Meetup events scraper searches public Meetup.com events by keyword + location — title, date/time, event type, venue, going/RSVP count, capacity, fee, and hosting group (name + Meetup URL). Export to JSON, CSV, or Excel. Public-only, no login, GDPR-safe (aggregate counts, no attendee PII).

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Meetup Events Scraper

**💰 $4.00 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

A **Meetup events scraper** for public Meetup.com listings — search by keyword and location and get title, date/time, event type, venue + geo, going/RSVP count, capacity, fee, and the hosting group (name + Meetup URL). Public-only, no login, GDPR-safe.

</div>

---

### 🎯 What this scrapes

Meetup is where AI, data, startup, and tech communities run their events — and every public listing is a B2B-intent signal. This Actor searches Meetup's public events feed by keyword (optionally scoped to a city), reads each event's server-rendered data (no login, no API key), and turns it into clean, structured rows: when and where the event is, whether it's in-person or online, how many people are going, the capacity, the fee, and which group is hosting it — with a direct link to that group's Meetup page.

Pair it with our **[Lu.ma Event Discovery Scraper](https://apify.com/DevilScrapes/luma-event-discovery)** for a two-Actor events-intelligence suite covering the same B2B buyer across both platforms.

### 🔥 What we handle for you

- 🛡️ **Browser fingerprint impersonation** — `curl-cffi` mimics real Chrome / Firefox / Safari TLS handshakes so Meetup serves a browser, not Python.
- 🌐 **Proxy rotation** via Apify Proxy — a fresh session and exit IP whenever you need one.
- 🔁 **Retries with exponential backoff** on `403 / 408 / 429 / 5xx` — up to 5 attempts per page, so a transient block never costs you a row.
- 🧮 **Aggregate RSVP counts, no PII** — we emit the "going" count only; individual attendee identities are never touched.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, stable IDs, JSON / CSV / Excel export straight from the Apify Console.
- 💰 **Pay-Per-Event pricing** — you only pay for events that land in your dataset. No data, no charge.

### 💡 Use cases

- **Event-led lead gen** — surface hosting groups and their Meetup pages for the topics your buyers care about.
- **Community & ecosystem mapping** — track which AI / data / startup groups are active in a city over time.
- **Competitive intelligence** — watch a rival's or partner's event cadence, turnout, and pricing.
- **Sponsorship prospecting** — find well-attended events worth a partnership pitch, ranked by going count.
- **Trend research** — aggregate events across keywords and cities to spot what's heating up.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Add one or more **keywords** (e.g. `ai`, `startup`) and, optionally, a **location** (e.g. `New York, NY`).
3. Pick an **event type** (any / physical / online) and click **Start**. Output streams into the run's dataset.
4. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch via the API.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `keywords` | `array` | **yes** | `["ai"]` | Search terms — one Meetup search per keyword. Accepts a bare string too. |
| `location` | `string` | no | — | City / region for the Meetup location filter (e.g. `New York, NY`). Leave empty for a global relevance search. |
| `eventType` | `string` | no | `any` | Filter emitted rows: `any`, `physical` (in-person), or `online` (virtual). |
| `maxEventsPerKeyword` | `integer` | no | `50` | Max events per keyword (`1`–`500`). One search page yields roughly 27; use several keywords for more breadth. |
| `includeDescription` | `boolean` | no | `true` | When off, `description` is emitted as null for a leaner row. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | Apify Proxy configuration. The default shared pool is sufficient. |

#### Example input

```json
{
  "keywords": ["ai", "startup"],
  "location": "New York, NY",
  "eventType": "any",
  "maxEventsPerKeyword": 50,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

### 📤 Output

Every row is one public event.

| Field | Type | Notes |
|---|---|---|
| `search_keyword` | `string` | The input keyword that produced this row. |
| `event_id` | `string` | Meetup internal event ID. |
| `title` | `string` | Event title. |
| `event_url` | `string` | Canonical public event URL. |
| `date_time` | `string` | Event start time (ISO-8601 with timezone offset). |
| `event_type` | `string` | `physical` or `online`. |
| `is_online` | `boolean` | True when the event is virtual. |
| `going_count` | `integer` | Number of members going (aggregate RSVP count). |
| `max_tickets` | `integer \| null` | Capacity cap, when the host set one. |
| `is_free` | `boolean` | True when the event has no fee. |
| `fee_amount` | `number \| null` | Ticket fee amount, when paid. |
| `fee_currency` | `string \| null` | ISO currency code of the fee, when paid. |
| `venue_name` | `string \| null` | Venue name, when present. |
| `venue_address` | `string \| null` | Venue street address, when present. |
| `venue_city` | `string \| null` | Venue city, when present. |
| `venue_state` | `string \| null` | Venue state / region, when present. |
| `venue_country` | `string \| null` | Venue country code, when present. |
| `latitude` | `number \| null` | Venue latitude, when the feed exposes it. |
| `longitude` | `number \| null` | Venue longitude, when the feed exposes it. |
| `group_name` | `string \| null` | Hosting group display name. |
| `group_url` | `string \| null` | Hosting group Meetup URL. |
| `description` | `string \| null` | Event description; null when `includeDescription` is off. |
| `scraped_at` | `string` | ISO-8601 timestamp of when this row was recorded. |

#### Example output

```json
{
  "search_keyword": "ai",
  "event_id": "315229748",
  "title": "Build the AI Future: LinuxONE & IBM Hands-On in NYC",
  "event_url": "https://www.meetup.com/ai-modeling-and-machine-learning-in-action-sponsored-by-ibm/events/315229748/",
  "date_time": "2026-07-21T08:30:00-04:00",
  "event_type": "physical",
  "is_online": false,
  "going_count": 50,
  "max_tickets": 50,
  "is_free": true,
  "fee_amount": null,
  "fee_currency": null,
  "venue_name": "IBM 1 Madison Avenue",
  "venue_address": "1 Madison Avenue",
  "venue_city": "NYC",
  "venue_state": "NY",
  "venue_country": "us",
  "latitude": null,
  "longitude": null,
  "group_name": "IBM AI - New York City",
  "group_url": "https://www.meetup.com/AI-Modeling-and-Machine-Learning-in-Action-Sponsored-by-IBM/",
  "description": "Join us in New York City for a full-day, hands-on meetup...",
  "scraped_at": "2026-07-10T15:00:00+00:00"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result` | $0.004 | Per event written to the dataset |

Example: 1 000 events ≈ **$4.00**. No subscription, no minimum, no card to start — Apify gives every new account $5 of free credit.

### 🔒 Privacy & GDPR

This Actor scrapes **public-by-design event metadata only**. Hosting groups are public organizer pages Meetup surfaces by design. RSVPs are emitted strictly as an **aggregate count** (`going_count`) — **individual attendee identities, emails, and phone numbers are never collected**. That's a deliberate design choice, not a limitation: the "who's going" list carries personal data, so we take only the number, never the people.

### 🚧 Limitations

- **Per-keyword results are page-limited.** Meetup's public find feed serves roughly the first ~27 events per search, and it does not expose a reliable cursor for deep pagination on this surface. We deliberately do **not** ship a fragile pagination hack (reliability beats depth — a Devil Scrapes rule). To widen coverage, run **several keywords** (and/or several locations) in one run; each keyword is its own search.
- **Geo coordinates are sparse.** The find feed exposes venue name and address but usually not latitude / longitude, so `latitude` / `longitude` are frequently null.
- **Public feed only.** Private, members-only, or draft events are not accessible.
- **Attendee lists are out of scope** — see Privacy & GDPR above.

### ❓ FAQ

**Do I need a Meetup login or API key?**

No. Everything comes from the public, server-rendered find feed — no auth at all.

**How many events do I get per keyword?**

Roughly the first page Meetup serves for that search (~27). For broader coverage, pass multiple keywords — each one runs its own search.

**Does it collect attendee data?**

No. We emit only the aggregate "going" count. Individual RSVP identities are never collected.

**Can I filter to only in-person or only online events?**

Yes. Set `eventType` to `physical` or `online`; leave it `any` for both.

**Why is `latitude` / `longitude` sometimes null?**

The public find feed usually exposes the venue name and address but not coordinates. We return null rather than guessing.

### 💬 Your feedback

Spotted a bug, hit a weird edge case, or need a new field? Open an
issue on the Actor's **Issues** tab on Apify Console — we ship
fixes weekly and we read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

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

Search terms — one Meetup search per keyword (e.g. 'ai', 'startup'). One search page returns roughly 27 events; use several keywords for more breadth.

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

City / region for the Meetup location filter (e.g. 'New York, NY'). Leave empty for a global relevance search.

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

Filter emitted rows by event type.

## `maxEventsPerKeyword` (type: `integer`):

Maximum events to collect per keyword. A single search page yields roughly 27 events.

## `includeDescription` (type: `boolean`):

When enabled, each row carries the event description. Turn off for a leaner row (description is emitted as null).

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

Apify Proxy configuration. Meetup serves this feed without a challenge; the default shared pool is sufficient.

## Actor input object example

```json
{
  "keywords": [
    "ai"
  ],
  "location": "New York, NY",
  "eventType": "any",
  "maxEventsPerKeyword": 50,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "keywords": [
        "ai"
    ],
    "location": "New York, NY",
    "eventType": "any",
    "maxEventsPerKeyword": 50,
    "includeDescription": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/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 = {
    "keywords": ["ai"],
    "location": "New York, NY",
    "eventType": "any",
    "maxEventsPerKeyword": 50,
    "includeDescription": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/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 '{
  "keywords": [
    "ai"
  ],
  "location": "New York, NY",
  "eventType": "any",
  "maxEventsPerKeyword": 50,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup Events Scraper",
        "description": "This Meetup events scraper searches public Meetup.com events by keyword + location — title, date/time, event type, venue, going/RSVP count, capacity, fee, and hosting group (name + Meetup URL). Export to JSON, CSV, or Excel. Public-only, no login, GDPR-safe (aggregate counts, no attendee PII).",
        "version": "0.1",
        "x-build-id": "xqKL8GbkXDtMPcMdH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~meetup-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-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/devilscrapes~meetup-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-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/devilscrapes~meetup-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search terms — one Meetup search per keyword (e.g. 'ai', 'startup'). One search page returns roughly 27 events; use several keywords for more breadth.",
                        "default": [
                            "ai"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City / region for the Meetup location filter (e.g. 'New York, NY'). Leave empty for a global relevance search."
                    },
                    "eventType": {
                        "title": "Event type",
                        "enum": [
                            "any",
                            "physical",
                            "online"
                        ],
                        "type": "string",
                        "description": "Filter emitted rows by event type.",
                        "default": "any"
                    },
                    "maxEventsPerKeyword": {
                        "title": "Max events per keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum events to collect per keyword. A single search page yields roughly 27 events.",
                        "default": 50
                    },
                    "includeDescription": {
                        "title": "Include description",
                        "type": "boolean",
                        "description": "When enabled, each row carries the event description. Turn off for a leaner row (description is emitted as null).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Meetup serves this feed without a challenge; the default shared pool is sufficient.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
