# Meetup Scraper (`solidcode/meetup-scraper`) Actor

\[💰 $0.45 / 1K] Search and extract events from Meetup.com by keyword, location, type, and date — including schedule, venue, organizing group, attendance counts, and fees.

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

## Pricing

from $0.45 / 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

Pull events from Meetup.com at scale — full schedule, GPS-located venue, organizing group with member count, RSVP attendance, and fee details in one flat row per event. Search by keyword and city or paste Meetup search and group URLs directly, and box results to a date window across any country on Earth. Built for event marketers, community managers, and developer-relations teams who need a clean, structured feed of who's gathering where without copying event details off Meetup pages one at a time.

### Why This Scraper?

- **Every event field in one flat row** — title, description, start/end time, duration in minutes, timezone, venue, group, attendance, and pricing all land on a single record. No nested digging, no per-event follow-up.
- **Venue GPS coordinates on every in-person event** — `latitude` and `longitude` alongside venue name, full address, and city, so you can map events or geo-filter without a separate geocoding step.
- **Organizing-group member counts** — each event carries its group's name, URL slug, and total member count, letting you weight events by community size at a glance.
- **In-person vs online vs both** — a single Event Type dropdown narrows to physical gatherings, online-only events, or all of them.
- **RSVP attendance and capacity** — current RSVP count and maximum capacity on every row, so you can spot the events that are actually filling up.
- **Free and paid pricing with currency** — paid-event flag, fee amount, currency code, and whether payment is required to attend, captured per event.
- **Date-range filtering** — set a start date, an end date, or both to box a single weekend, a launch week, or a full quarter of upcoming events.
- **Search a city or paste a Meetup URL** — feed a keyword plus location, a `/find/?keywords=` search link, or a group's `/events/` page to track one community over time.
- **Global coverage, no login** — works for any country and city worldwide and runs without a Meetup account, with a built-in country selector to disambiguate same-named cities.

### Use Cases

**Event Marketing**
- Find every javascript, yoga, or startup-networking event in a target city for the next month
- Track which event topics are drawing the largest RSVP counts
- Build a calendar of competing or complementary events around your own launch
- Identify paid vs free events to benchmark ticket pricing in your niche

**Community Management**
- Monitor a specific group's upcoming events by pasting its `/events/` URL
- Compare your community's event cadence against similar groups by member count
- Spot high-attendance venues to scout for your next in-person meetup
- Track online vs in-person trends within a topic over a date range

**Developer Relations**
- Map tech meetups (React, Kubernetes, data engineering) across multiple cities for sponsorship targeting
- Surface the largest developer communities by member count in each market
- Find online events to join or speak at without geographic limits
- Build a recurring feed of relevant events to share with your developer audience

**Lead Generation & Outreach**
- Identify active organizing groups and their public group pages for partnership outreach
- Source events by venue city to plan field-marketing routes
- Prioritize outreach by RSVP momentum and group size

**Market Research**
- Measure event volume and pricing across countries and categories
- Track how many events in a topic are online vs in-person
- Analyze venue concentration and attendance to gauge demand in a region

### Getting Started

#### Search by Keyword

The simplest run — one keyword, results near the default location:

```json
{
    "searchKeyword": "javascript",
    "maxResults": 50
}
````

#### Keyword in a Specific City

Add a location, a country to disambiguate, and limit to in-person events:

```json
{
    "searchKeyword": "startup networking",
    "location": "Berlin, Germany",
    "country": "DE",
    "eventType": "in-person",
    "maxResults": 100
}
```

#### Track a Group by URL

Paste a group's events page to pull that community's upcoming events:

```json
{
    "startUrls": [
        "https://www.meetup.com/nyc-javascript-meetup/events/"
    ],
    "maxResults": 50
}
```

#### Box a Date Window

Combine keyword, location, and a start/end date range:

```json
{
    "searchKeyword": "yoga",
    "location": "Austin, TX",
    "country": "US",
    "eventType": "any",
    "startDate": "2026-06-01",
    "endDate": "2026-06-30",
    "maxResults": 200
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchKeyword` | string | none (suggested: `"javascript"`) | Topic or keyword to find events for, such as "yoga" or "startup networking". The field is pre-filled with "javascript" as an editable suggestion — clear or change it freely. Leave it empty if you only want to scrape pasted Meetup URLs. |
| `location` | string | `""` | City or region to search in, such as "Berlin, Germany" or "Austin, TX". Leave empty to default to New York. |
| `country` | select | `Auto-detect` | Optional country to pinpoint the right location when a city name exists in several countries. |
| `startUrls` | string\[] | `[]` | Paste Meetup search URLs (`/find/?keywords=`) or group URLs (`/your-group/events/`) to scrape events directly. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `eventType` | select | `Any (in-person & online)` | Limit results to in-person events, online events, or include both. |
| `startDate` | string | `null` | Only include events on or after this date, in `YYYY-MM-DD` format. Leave empty for all upcoming events. |
| `endDate` | string | `null` | Only include events on or before this date, in `YYYY-MM-DD` format. Leave empty for no end limit. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of events to return. Set to 0 for unlimited. Start with 100-1,000 to keep costs reasonable. |

### Output

Each event is a single flat record. Here's a representative result:

```json
{
    "eventId": "298765432",
    "eventName": "Modern JavaScript: Patterns & Performance",
    "eventUrl": "https://www.meetup.com/nyc-javascript-meetup/events/298765432/",
    "description": "Join us for a hands-on evening covering design patterns, bundling, and runtime performance...",
    "eventType": "in-person",
    "dateTime": "2026-06-12T18:30:00-04:00",
    "endTime": "2026-06-12T21:00:00-04:00",
    "duration": 150,
    "timezone": "US/Eastern",
    "status": "active",
    "imageUrl": "https://secure.meetupstatic.com/photos/event/highres.jpeg",
    "address": "511 W 25th St, 7th Floor",
    "venueName": "DevHub NYC",
    "city": "New York",
    "latitude": 40.7484,
    "longitude": -73.9857,
    "groupName": "NYC JavaScript Meetup",
    "groupUrlname": "nyc-javascript-meetup",
    "groupMemberCount": 18420,
    "maxAttendees": 120,
    "actualAttendees": 87,
    "isPaidEvent": true,
    "feeAmount": 10,
    "feeCurrency": "USD",
    "feeRequired": true
}
```

#### Core Event

| Field | Type | Description |
|-------|------|-------------|
| `eventId` | string | Unique Meetup event identifier |
| `eventName` | string | Event title |
| `eventUrl` | string | Direct link to the event page |
| `description` | string | Full event description text |
| `eventType` | string | "in-person" or "online" |
| `status` | string | Event status (active, past, cancelled) |
| `imageUrl` | string | Event photo URL when present |

#### Date & Time

| Field | Type | Description |
|-------|------|-------------|
| `dateTime` | string | Start date and time (ISO 8601 with timezone) |
| `endTime` | string | End date and time (ISO 8601) when available |
| `duration` | integer | Event length in minutes when available |
| `timezone` | string | Event timezone |

#### Venue & Location

| Field | Type | Description |
|-------|------|-------------|
| `venueName` | string | Venue name |
| `address` | string | Full venue address, or "Online event" |
| `city` | string | Venue city |
| `latitude` | number | Venue latitude |
| `longitude` | number | Venue longitude |

#### Group & Attendance

| Field | Type | Description |
|-------|------|-------------|
| `groupName` | string | Organizing group name |
| `groupUrlname` | string | Group URL identifier (slug) |
| `groupMemberCount` | integer | Total members of the organizing group when available |
| `maxAttendees` | integer | RSVP capacity |
| `actualAttendees` | integer | Current RSVP count |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `isPaidEvent` | boolean | Whether the event has a fee |
| `feeAmount` | number | Fee value |
| `feeCurrency` | string | Fee currency code (e.g. USD, EUR) |
| `feeRequired` | boolean | Whether payment is mandatory to attend |

### Tips for Best Results

- **Location defaults to New York** — if you leave the location empty, results come from New York, the largest Meetup market. Always set a location to search the city you actually care about.
- **A keyword does the heavy lifting** — searches return the most relevant events when you give a clear topic like "react", "hiking", or "product management". A location with no keyword returns little.
- **Track one community by pasting its events page** — drop a group's `/your-group/events/` URL into Meetup URLs to pull that group's upcoming events directly, no keyword needed. Ideal for monitoring competitors or your own community over time.
- **Use the country selector for ambiguous cities** — "Cambridge" or "Springfield" exist in many countries; setting the country pins the search to the right one.
- **Box a tight date window** — combine `startDate` and `endDate` to capture a single weekend or launch week and avoid pulling months of irrelevant events.
- **Start small, then scale** — run with `maxResults` at 50-100 first to confirm the data fits your needs, then raise the cap or set it to 0 for unlimited.
- **Mix keyword search and URLs in one run** — paste several group and search URLs together to build a combined feed in a single pass.

### Pricing

**$0.45 per 1,000 results** — a flat pay-per-result rate that undercuts comparable Meetup event extractors.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.045 |
| 1,000 | $0.45 |
| 10,000 | $4.50 |
| 100,000 | $45.00 |

A "result" is one event record in the output dataset. **No compute charges — you only pay per result returned.** Apify platform fees (storage, data transfer) depend on your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate event research, community analysis, and marketing planning. It collects only publicly available event information and aggregate attendance counts — never individual attendee rosters or personal contact details. Users are responsible for complying with applicable laws and Meetup's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `searchKeyword` (type: `string`):

Topic or keyword to find events for, such as 'javascript', 'yoga', or 'startup networking'. Leave empty if you only want to scrape pasted Meetup URLs.

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

City or region to search in, such as 'Berlin, Germany', 'Austin, TX', or 'London'. Leave empty to search everywhere.

## `country` (type: `string`):

Optional. Helps pinpoint the right location when a city name exists in several countries. Leave on Auto-detect if unsure.

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

Optional. Paste Meetup search URLs or group URLs (for example https://www.meetup.com/find/?keywords=python or https://www.meetup.com/some-group/events/) to scrape events directly.

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

Limit results to in-person events, online events, or include both.

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

Only include events on or after this date. Use the format YYYY-MM-DD, for example 2026-06-01. Leave empty for all upcoming events.

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

Only include events on or before this date. Use the format YYYY-MM-DD, for example 2026-06-30. Leave empty for no end limit.

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

Maximum number of events to return. Set to 0 for unlimited. Recommended: 100-1000 to keep costs reasonable.

## Actor input object example

```json
{
  "searchKeyword": "javascript",
  "country": "",
  "startUrls": [],
  "eventType": "any",
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped events with key fields.

## `venues` (type: `string`):

Venue and geo details for each event.

# 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 = {
    "searchKeyword": "javascript",
    "location": "",
    "country": "",
    "startUrls": [],
    "eventType": "any",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchKeyword": "javascript",
    "location": "",
    "country": "",
    "startUrls": [],
    "eventType": "any",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchKeyword": "javascript",
  "location": "",
  "country": "",
  "startUrls": [],
  "eventType": "any",
  "maxResults": 100
}' |
apify call solidcode/meetup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup Scraper",
        "description": "[💰 $0.45 / 1K] Search and extract events from Meetup.com by keyword, location, type, and date — including schedule, venue, organizing group, attendance counts, and fees.",
        "version": "1.0",
        "x-build-id": "8r4otUAFhdFhDNkag"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~meetup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~meetup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~meetup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchKeyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Topic or keyword to find events for, such as 'javascript', 'yoga', or 'startup networking'. Leave empty if you only want to scrape pasted Meetup URLs."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to search in, such as 'Berlin, Germany', 'Austin, TX', or 'London'. Leave empty to search everywhere."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "NZ",
                            "IE",
                            "NL",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "PT",
                            "BE",
                            "LU",
                            "AT",
                            "CH",
                            "PL",
                            "CZ",
                            "SK",
                            "HU",
                            "RO",
                            "BG",
                            "HR",
                            "GR",
                            "DK",
                            "SE",
                            "NO",
                            "FI",
                            "TR",
                            "IL",
                            "AE",
                            "SA",
                            "JP",
                            "KR",
                            "CN",
                            "IN",
                            "TH",
                            "SG",
                            "MY",
                            "ID",
                            "PH",
                            "VN",
                            "BR",
                            "MX",
                            "AR",
                            "CO",
                            "CL",
                            "PE",
                            "ZA",
                            "NG",
                            "EG",
                            "KE",
                            "MA",
                            "RU",
                            "UA"
                        ],
                        "type": "string",
                        "description": "Optional. Helps pinpoint the right location when a city name exists in several countries. Leave on Auto-detect if unsure.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Meetup URLs",
                        "type": "array",
                        "description": "Optional. Paste Meetup search URLs or group URLs (for example https://www.meetup.com/find/?keywords=python or https://www.meetup.com/some-group/events/) to scrape events directly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "eventType": {
                        "title": "Event Type",
                        "enum": [
                            "any",
                            "in-person",
                            "online"
                        ],
                        "type": "string",
                        "description": "Limit results to in-person events, online events, or include both.",
                        "default": "any"
                    },
                    "startDate": {
                        "title": "Start Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include events on or after this date. Use the format YYYY-MM-DD, for example 2026-06-01. Leave empty for all upcoming events."
                    },
                    "endDate": {
                        "title": "End Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only include events on or before this date. Use the format YYYY-MM-DD, for example 2026-06-30. Leave empty for no end limit."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of events to return. Set to 0 for unlimited. Recommended: 100-1000 to keep costs reasonable.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
