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

Scrape upcoming Meetup.com events in bulk by keyword and city. Get event title, date/time, venue address, hosting group and member count, RSVP count, ticket price and event URL as clean JSON. No login or API key needed.

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

## Pricing

from $3.00 / 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Meetup Events Scraper

**Scrape upcoming Meetup.com events in bulk — by keyword and city.** Give the actor
a list of search keywords and a list of locations, and it returns every matching
upcoming event as a clean, structured row: title, date and time, in-person or online,
the full venue address (with latitude/longitude), the hosting group (name, URL and
member count), the number of people going, the ticket price for paid events, and the
event link. No login, no API key.

It reads Meetup's own public event-search data directly, so results are exact and
paginate deep — a handful of keywords across a few cities returns **thousands of
events in one run**.

---

### What you get (output fields)

Each row is one event:

| Field | Description |
|---|---|
| `eventId` | Meetup's numeric event id |
| `title` | Event title |
| `dateTime` / `endTime` | Start / end, ISO 8601 with the local time-zone offset |
| `eventType` | `PHYSICAL` (in-person) or `ONLINE` |
| `isOnline` | Boolean shortcut for online events |
| `eventUrl` / `shortUrl` | Direct links to the event page |
| `description` | Full event description text |
| `goingCount` | Number of people who RSVP'd "going" |
| `maxTickets` | Attendee cap (0 / null = no cap) |
| `guestsAllowed` | Whether attendees can bring guests |
| `status` | `ACTIVE`, `CANCELLED`, etc. |
| `createdTime` | When the event was created |
| `isFree` | `true` for free events |
| `priceAmount` / `priceCurrency` | Ticket price for paid events |
| `paymentAccepts` / `paymentRequired` | How payment is taken, and whether it's required |
| `venueName`, `venueAddress`, `venueCity`, `venueState`, `venueCountry`, `venuePostalCode` | Full venue address |
| `venueLat` / `venueLon` | Venue coordinates |
| `groupId`, `groupName`, `groupUrlname`, `groupUrl` | The hosting Meetup group |
| `groupCity`, `groupState`, `groupCountry`, `groupTimezone` | Group location |
| `groupMemberCount` | How many members the group has |
| `groupFoundedDate`, `groupIsPrivate`, `groupIsNew` | Group metadata |
| `photoUrl` | Event cover photo |
| `searchQuery` / `searchLocation` | Which keyword + resolved location found this event |
| `scrapedAt` | Scrape timestamp (UTC) |

---

### Input

| Field | Description |
|---|---|
| `queries` | **Keywords to search** (array). Each keyword is searched in each location. |
| `locations` | **Places to search** (array of plain text, e.g. `"New York, NY"`, `"London"`). Resolved to Meetup's coordinates automatically. |
| `radius` | Search radius in miles (default `50`, max `100`). |
| `eventType` | `any`, `physical`, or `online`. |
| `sort` | `relevance` or `date` (soonest first). |
| `startDate` / `endDate` | Optional `YYYY-MM-DD` bounds (defaults from today). |
| `maxResultsPerSearch` | Cap per keyword × location (default `500`). |
| `maxResults` | Optional overall cap across all searches. |
| `proxyConfiguration` | Proxy (defaults to Apify Residential, US). |

Every keyword is searched in every location (**keyword × location**), and each search
is paginated deep automatically (~50 events per page). So `["technology", "startup"]`
× `["New York, NY", "San Francisco, CA"]` = 4 deep searches in one run. Events are
de-duplicated by event id, so you're never charged twice for the same event.

#### Example input

```json
{
  "queries": ["technology", "startup", "artificial intelligence"],
  "locations": ["New York, NY", "San Francisco, CA"],
  "radius": 50,
  "eventType": "any",
  "sort": "relevance",
  "maxResultsPerSearch": 500
}
````

***

### Example output (one row)

```json
{
  "eventId": "315073761",
  "title": "Stripe developer meetup New York, July 2026 (In Person)",
  "dateTime": "2026-07-21T18:00:00-04:00",
  "endTime": "2026-07-21T20:00:00-04:00",
  "eventType": "PHYSICAL",
  "isOnline": false,
  "eventUrl": "https://www.meetup.com/stripe-new-york/events/315073761/",
  "goingCount": 208,
  "maxTickets": 214,
  "isFree": true,
  "venueName": "Stripe Office NY",
  "venueAddress": "28 Liberty St. Fl. 48  New York, NY 10005",
  "venueCity": "New York",
  "venueState": "NY",
  "venueLat": 40.707752,
  "venueLon": -74.008705,
  "groupName": "Stripe New York",
  "groupUrl": "https://www.meetup.com/stripe-new-york",
  "groupMemberCount": 777,
  "photoUrl": "https://secure.meetupstatic.com/photos/event/a/7/e/9/highres_534582985.jpeg",
  "searchQuery": "technology",
  "searchLocation": "New York, NY, USA",
  "scrapedAt": "2026-07-19T12:00:00+00:00"
}
```

***

### Use cases

- **Event marketing & sponsorship leads** — find every relevant meetup in a city, with
  the group, organizer URL, member count and attendance so you can target the ones
  worth sponsoring or speaking at.
- **Community & competitive research** — track which groups are active, how big they
  are, and how many people show up for a topic across multiple cities.
- **Local listings & newsletters** — pull a fresh, structured feed of upcoming events
  (with venue addresses and links) for a "what's on" site or newsletter.
- **Sales prospecting** — surface companies and communities gathering around a topic
  (AI, crypto, real estate, fitness…) in your target metros.

***

### FAQ

**Do I need a Meetup account or API key?** No. The actor reads Meetup's public event
search, the same data the website shows.

**How many events per run?** As many as Meetup lists. Each keyword+city search
paginates deep (hundreds of events), and you can run many keyword×city combinations,
so runs of thousands of events are normal. Use `maxResultsPerSearch` / `maxResults`
to cap it.

**Can I get only in-person or only online events?** Yes — set `eventType` to
`physical` or `online`.

**Why do I have to give a location?** Meetup's event search is geographic — even online
events are attached to a region — so every search is centered on a place. Use `radius`
to widen the area (up to 100 miles).

**How is it billed?** Pay per event: you're charged once for each event returned.
Duplicate events (the same event matching two keywords) are removed before billing.

**Past events?** Never returned — the actor only lists upcoming events (from `startDate`,
which defaults to today).

# Actor input Schema

## `queries` (type: `array`):

One or more keywords to search Meetup events for (e.g. 'technology', 'yoga', 'startup', 'jazz'). Every keyword is searched in every location you list below (keyword x location), so 3 keywords x 3 cities = 9 searches, each paginated deep. A keyword is required - Meetup search returns nothing for an empty keyword. Results are billed per event, so more keywords = more rows.

## `locations` (type: `array`):

One or more places to search around, as plain text (e.g. 'New York, NY', 'San Francisco', 'London', 'Berlin, Germany'). Each is resolved to the best-matching Meetup location automatically. Every keyword above is searched in every location here. Online events are still tied to a region by Meetup, so a location is always needed. Use the 'Search radius' below to widen or narrow the area around each location.

## `radius` (type: `integer`):

How far around each location to search, in miles. Larger radius = more events (and more rows). 50 miles covers a metro area; use 100 to sweep a whole region.

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

Filter by how the event is held: any (both), only in-person events, or only online events.

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

How to order events within each search: by relevance to the keyword, or soonest date first. Sorting only affects which events you see first when you cap the results; with a high cap you get the same full set either way.

## `startDate` (type: `string`):

Only include events on or after this date, as YYYY-MM-DD (e.g. 2026-08-01). Leave empty to start from today (past events are never returned).

## `endDate` (type: `string`):

Only include events on or before this date, as YYYY-MM-DD (e.g. 2026-12-31). Leave empty for no upper bound.

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

Maximum events to return for EACH keyword x location search. The actor paginates automatically (~50 events per page). Set high to pull everything Meetup has for that keyword+city; lower it to sample.

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

Optional overall cap across ALL keyword x location searches combined. Leave empty for no overall cap (each search is still bounded by Max results per search). Useful to cap total billed rows for a run.

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

Proxy for reaching Meetup. The actor calls Meetup's public data endpoint directly first, and rotates through this proxy on any rate-limit / block. The default (Apify Residential, US) is a safe choice; leave it in place.

## Actor input object example

```json
{
  "queries": [
    "technology",
    "startup",
    "artificial intelligence"
  ],
  "locations": [
    "New York, NY",
    "San Francisco, CA",
    "London"
  ],
  "radius": 50,
  "eventType": "any",
  "sort": "relevance",
  "maxResultsPerSearch": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "queries": [
        "technology"
    ],
    "locations": [
        "New York, NY"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/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 = {
    "queries": ["technology"],
    "locations": ["New York, NY"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/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 '{
  "queries": [
    "technology"
  ],
  "locations": [
    "New York, NY"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapeworks/meetup-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup Events Scraper",
        "description": "Scrape upcoming Meetup.com events in bulk by keyword and city. Get event title, date/time, venue address, hosting group and member count, RSVP count, ticket price and event URL as clean JSON. No login or API key needed.",
        "version": "0.1",
        "x-build-id": "yM3q1Uefk3XJaYk7K"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~meetup-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-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/scrapeworks~meetup-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-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/scrapeworks~meetup-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-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": [
                    "queries",
                    "locations"
                ],
                "properties": {
                    "queries": {
                        "title": "Search keywords",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more keywords to search Meetup events for (e.g. 'technology', 'yoga', 'startup', 'jazz'). Every keyword is searched in every location you list below (keyword x location), so 3 keywords x 3 cities = 9 searches, each paginated deep. A keyword is required - Meetup search returns nothing for an empty keyword. Results are billed per event, so more keywords = more rows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations (city, region)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more places to search around, as plain text (e.g. 'New York, NY', 'San Francisco', 'London', 'Berlin, Germany'). Each is resolved to the best-matching Meetup location automatically. Every keyword above is searched in every location here. Online events are still tied to a region by Meetup, so a location is always needed. Use the 'Search radius' below to widen or narrow the area around each location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "radius": {
                        "title": "Search radius (miles)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How far around each location to search, in miles. Larger radius = more events (and more rows). 50 miles covers a metro area; use 100 to sweep a whole region.",
                        "default": 50
                    },
                    "eventType": {
                        "title": "Event type",
                        "enum": [
                            "any",
                            "physical",
                            "online"
                        ],
                        "type": "string",
                        "description": "Filter by how the event is held: any (both), only in-person events, or only online events.",
                        "default": "any"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "How to order events within each search: by relevance to the keyword, or soonest date first. Sorting only affects which events you see first when you cap the results; with a high cap you get the same full set either way.",
                        "default": "relevance"
                    },
                    "startDate": {
                        "title": "Earliest event date (optional)",
                        "type": "string",
                        "description": "Only include events on or after this date, as YYYY-MM-DD (e.g. 2026-08-01). Leave empty to start from today (past events are never returned)."
                    },
                    "endDate": {
                        "title": "Latest event date (optional)",
                        "type": "string",
                        "description": "Only include events on or before this date, as YYYY-MM-DD (e.g. 2026-12-31). Leave empty for no upper bound."
                    },
                    "maxResultsPerSearch": {
                        "title": "Max results per search",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum events to return for EACH keyword x location search. The actor paginates automatically (~50 events per page). Set high to pull everything Meetup has for that keyword+city; lower it to sample.",
                        "default": 500
                    },
                    "maxResults": {
                        "title": "Max results overall (optional)",
                        "minimum": 1,
                        "maximum": 200000,
                        "type": "integer",
                        "description": "Optional overall cap across ALL keyword x location searches combined. Leave empty for no overall cap (each search is still bounded by Max results per search). Useful to cap total billed rows for a run."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy for reaching Meetup. The actor calls Meetup's public data endpoint directly first, and rotates through this proxy on any rate-limit / block. The default (Apify Residential, US) is a safe choice; leave it in place.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
