# Meetup \[$0.99] Events · Groups · Members · RSVP · Topics (`memo23/meetup-scraper`) Actor

Scrape Meetup events with the host group behind each — name, date, online/in-person, venue + geo, fee, RSVP/going count, and the group's member count, location & topics. Optionally enrich each group with a business contact email (billed per email found). One row per event. JSON/CSV.

- **URL**: https://apify.com/memo23/meetup-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

**Turn Meetup into structured event + community data.** Scrape events from any Meetup find, group, or event URL — title, full description, date/time with timezone, online vs in-person, venue + real lat/long, fee, **RSVP / going count**, and the **host group** (name, member count, location, topic category, topics). **Optionally enrich each host group with a business contact email** (opt-in, billed only per email found). One row per event, JSON or CSV out, billed per result.

#### How it works

![How Meetup Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-meetup.png)

#### ✨ Why use this scraper?

Building an events feed? Mapping active communities by topic and size? Tracking which groups are growing and what they're hosting? This actor pulls the full event *and* the group behind it in a single row.

- 🎯 **Three starting points.** Paste a Meetup find/search URL (`/find/?source=EVENTS&keywords=...`), a group URL (`/{group}/` or `/{group}/events/`), or a direct event URL (`/{group}/events/{id}`) — all classified automatically. Or just set **keyword + location** and let the actor build the search.
- 👥 **Group + member intelligence.** Every event row carries its host group's name, **member count**, city/country, topic category, and topics — perfect for finding active communities by size and subject.
- ✅ **RSVP / attendance signal.** `going` (confirmed RSVPs) and `waitlist` counts show real traction per event.
- 📧 **Optional email lead-gen.** Flip on `enrichEmails` to discover a business contact email for each host group (from its name) — adds `contactEmail` + `contactWebsite`. Experimental; billed only per email actually found, never for misses.
- 📍 **Online vs in-person, with geo.** In-person events include venue name, city, country, and real `latitude` / `longitude`; online events are flagged `isOnline: true`.
- 💸 **Fee captured.** `isFree` plus `feeAmount` / `feeCurrency` when an event charges.
- 🔁 **Monitoring mode.** Run on a schedule and get only NEW events each time — the actor keeps a private per-user record of what it already delivered.
- 🧰 **No anti-bot, no auth.** Reliable, fast parallel fetching — the event data is read straight from the page.
- 📤 **Clean exports.** One row per event with the group merged inline — no duplicate rows. JSON + CSV.

#### 🎯 Use cases

| Team | What they build |
|------|-----------------|
| **Event aggregators / city guides** | Fresh event feeds by topic + location, with group, venue, date, and RSVP counts |
| **Developer relations / community teams** | Find active groups by topic and member size to partner with or sponsor |
| **Market & community research** | Map a topic's community footprint — group sizes, cadence, attendance |
| **Sponsorship / BD** | Target groups above a member threshold in a category or city |
| **Competitive intelligence** | Track a community's events, growth, and topics over time |
| **Data journalists / researchers** | Datasets on local meetup activity, attendance, and community trends |

#### 📥 Supported inputs

Pass any mix of URLs in `startUrls` — each is classified automatically. Leave `startUrls` empty to build a find search from the convenience fields.

| URL pattern | Behaviour |
|---|---|
| `https://www.meetup.com/find/?source=EVENTS&keywords=...` | **Find / search** — collects the events listed on the page |
| `https://www.meetup.com/{group}/` or `/{group}/events/` | **Group** — collects that group's events |
| `https://www.meetup.com/{group}/events/{id}` | **Event detail** — routed straight to the parser |
| *keyword + location* | The actor builds `https://www.meetup.com/find/?source=EVENTS&keywords={keyword}&location={location}` |

Easiest workflow: run a search on meetup.com in your browser, copy the URL from the address bar, paste it into `startUrls`.

**Not supported:** authenticated/member-only data, hosts outside `meetup.com`.

> **Note on volume:** Meetup's find page uses infinite-scroll (cursor) pagination rather than numbered pages, so each find URL yields the events present on it. For breadth, pass several find/group URLs (different keywords, locations, or groups) in one run.

#### 🔄 How it works

1. **Classify each `startUrl`** as a find, group, or event URL (or build a find URL from `keyword` + `location`).
2. **Collect event links** (`/{group}/events/{id}`) from each find/group page.
3. **Fetch each event detail page** in parallel via a global sliding window.
4. **Extract the event's structured data** straight from the page — venue, group, hosts, and topics all included, with no separate group fetch.
5. **Push one row per event** to the dataset.

#### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | `["https://www.meetup.com/find/?source=EVENTS&keywords=technology"]` | Meetup find, group, and/or event URLs. Mix freely. |
| `keyword` | string | — | Keyword for the built find search. Used only when `startUrls` is empty. |
| `location` | string | — | Meetup location token (e.g. `us--ny--New_York`). Used only when `startUrls` is empty. |
| `monitoringMode` | boolean | `false` | Only return events not delivered to you on a previous run. The first run seeds the baseline. |
| `resetMonitoringState` | boolean | `false` | One-shot: clear the saved "events seen" record at run start. |
| `enrichEmails` | boolean | `false` | **Experimental — billed per email found.** Discover a business contact email for each host group (from its name). Adds `contactEmail`, `contactWebsite`, and a detailed `emailEnrichment` object. Only charged when an email is returned, never for misses. |
| `maxItems` | integer | `1000` | Hard cap on events collected (controls billing). |
| `maxConcurrency` / `minConcurrency` | integer | `10` / `1` | Parallel HTTP request limits. |
| `proxy` | object | Apify residential | Apify proxy configuration. Meetup has no aggressive anti-bot. |

#### 📊 Output overview

Each scraped event is one **single dataset row** of `type: "event"`, with its host group merged inline — no separate group rows, so the dataset row count equals the event count exactly.

#### 📦 Output sample

One row per event:

```json
{
    "type": "event",
    "eventId": "315135716",
    "eventUrl": "https://www.meetup.com/joinmytrip-dublin-travel-club/events/315135716/",
    "name": "Novalja Summer Getaway: Peak July Beach & Festival Crew!",
    "description": "Ready to escape to the \"Croatian Ibiza\" this summer? …",
    "status": "ACTIVE",
    "eventType": "PHYSICAL",
    "isOnline": false,
    "startDate": "2026-06-22T19:00:00+01:00",
    "endDate": "2026-06-22T21:00:00+01:00",
    "image": "https://secure.meetupstatic.com/photos/event/e/a/2/9/highres_534599945.jpeg",
    "going": 1,
    "waitlist": 0,
    "maxTickets": 0,
    "guestsAllowed": false,
    "isFree": true,
    "feeAmount": null,
    "feeCurrency": null,
    "venueName": "Novalja",
    "venueCity": "Novalja",
    "venueCountry": "hr",
    "latitude": 44.556763,
    "longitude": 14.882576,
    "groupName": "The Dublin Travelers Club - JoinMyTrip",
    "groupUrlname": "joinmytrip-dublin-travel-club",
    "groupUrl": "https://www.meetup.com/joinmytrip-dublin-travel-club",
    "groupCity": "Dublin",
    "groupCountry": "ie",
    "groupMembers": 5803,
    "groupTopicCategory": "Travel & Outdoor",
    "groupIsPrivate": false,
    "hosts": ["Gabo"],
    "topics": ["Partying", "Solo Travelers", "Travel", "Vacations"],
    "scrapedAt": "2026-06-12T12:15:42.957Z"
}
````

#### 🗂 Key output fields

| Group | Fields |
|---|---|
| **Identifiers** | `type`, `eventId`, `eventUrl`, `scrapedAt` |
| **Event** | `name`, `description`, `status`, `eventType`, `isOnline`, `image` |
| **Schedule** | `startDate`, `endDate` (ISO with offset) |
| **Attendance / tickets** | `going` (confirmed RSVPs), `waitlist`, `maxTickets`, `guestsAllowed`, `isFree`, `feeAmount`, `feeCurrency` |
| **Venue** | `venueName`, `venueAddress`, `venueCity`, `venueState`, `venueCountry`, `latitude`, `longitude` *(null for online events)* |
| **Host group** | `groupName`, `groupUrlname`, `groupUrl`, `groupCity`, `groupState`, `groupCountry`, `groupMembers`, `groupTopicCategory`, `groupIsPrivate`, `groupIsProNetwork` |
| **People / topics** | `hosts[]` (host names), `topics[]` |
| **Contact** *(only when `enrichEmails: true`)* | `contactEmail`, `contactWebsite`, `emailEnrichment` (full discovery detail) |

#### ❓ FAQ

**Which Meetup URLs are supported?**
Find/search URLs (`/find/?source=EVENTS&keywords=...`), group URLs (`/{group}/`, `/{group}/events/`), and event URLs (`/{group}/events/{id}`). You can also skip URLs and set `keyword` + `location`.

**Why don't I get hundreds of events from one find URL?**
Meetup's find page uses cursor (infinite-scroll) pagination, not numbered pages, so each find URL returns the events present on it. For more, pass multiple find/group URLs (different keywords, locations, or specific groups) in one run.

**Why are venue/geo fields `null` for some events?**
Those are online events (`isOnline: true`) — there's no physical venue.

**Can I get contact emails for the host groups?**
Optionally, yes. Meetup itself doesn't expose organizer contact details, but with `enrichEmails: true` the actor discovers a **business contact email** for each host group from its name (experimental). It adds `contactEmail`, `contactWebsite`, and an `emailEnrichment` detail object, and is **billed only per email actually found** — never for misses. Leave it off (the default) for pure event/community data.

**How does monitoring mode work?**
With `monitoringMode: true`, events whose ID was already delivered to you are skipped (no fetch, no charge). The first run seeds your baseline; later runs return only new events.

**Can I scrape private or member-only data?**
No. The scraper accesses only publicly available event and group pages — no logged-in content, no attendee personal data.

#### 💬 Support

- For issues or feature requests, please use the **Issues** tab on the actor's Apify Console page.
- Author's website: <https://muhamed-didovic.github.io/>
- Email: <muhamed.didovic@gmail.com>

#### 🛠 Additional services

- Custom output shape, extra fields, or one-off datasets: <muhamed.didovic@gmail.com>
- Need a similar scraper for other event sites (Eventbrite, Lu.ma, etc.)? Drop an email.
- For API access (no Apify fee, just a usage fee for the API): <muhamed.didovic@gmail.com>

#### 🔎 Explore more scrapers

If this Meetup Scraper was useful, see other scrapers and actors at [memo23's Apify profile](https://apify.com/memo23) — covering events, job boards, real estate, social media, and more.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Meetup, Meetup.com, or any of their subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available event and group pages on meetup.com — no authenticated endpoints, member-only features, or attendee personal data. Users are responsible for ensuring their use complies with Meetup's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organisation.

***

### SEO Keywords

meetup scraper, scrape meetup, meetup api, meetup.com scraper, apify meetup, meetup events scraper, meetup events data, meetup group scraper, meetup group members, meetup rsvp data, meetup attendance scraper, scrape events by city, event data api, meetup community data, meetup topic scraper, developer community scraper, tech meetup data, meetup group size, local events feed, meetup monitoring, meetup organizer emails, meetup group contact email, meetup lead generation, eventbrite alternative scraper, luma events scraper

# Actor input Schema

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

Full Meetup URLs to crawl. Mix find, group, and event URLs in the same array if useful.

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

Free-text keyword for the Meetup find page (used only when no Start URLs are given). E.g. `technology`, `yoga`, `startup`.

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

Meetup location token used to build a find search (used only when no Start URLs are given). Tip: run a search on meetup.com and copy the `location=` value from the URL, e.g. `us--ny--New_York`.

## `monitoringMode` (type: `boolean`):

When enabled, events whose ID has already been delivered to you are silently skipped (no detail page is fetched, no charge applies). The first run after enabling monitoring returns every match — that builds your baseline. Every subsequent run returns only new events.

## `resetMonitoringState` (type: `boolean`):

One-shot toggle: clear the saved 'events already seen' record at the start of this run. Has no effect when monitoring mode is off.

## `maxItems` (type: `integer`):

Hard cap on the number of events collected across all start URLs. Use this to control billing.

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

Maximum number of event pages processed in parallel.

## `minConcurrency` (type: `integer`):

Minimum number of event pages processed in parallel.

## `maxRequestRetries` (type: `integer`):

Number of retries before a failed request is given up.

## `enrichEmails` (type: `boolean`):

If enabled, finds a contact email for each result from its own website (or by discovering it from the name). Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.

## `proxy` (type: `object`):

Apify proxy settings. Meetup has no aggressive anti-bot, so a small residential pool (or even datacenter) works fine.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.meetup.com/find/?source=EVENTS&keywords=technology"
  ],
  "keyword": "technology",
  "location": "us--ny--New_York",
  "monitoringMode": false,
  "resetMonitoringState": false,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 5,
  "enrichEmails": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.meetup.com/find/?source=EVENTS&keywords=technology"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "startUrls": ["https://www.meetup.com/find/?source=EVENTS&keywords=technology"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "startUrls": [
    "https://www.meetup.com/find/?source=EVENTS&keywords=technology"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/meetup-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Meetup [$0.99] Events · Groups · Members · RSVP · Topics",
        "description": "Scrape Meetup events with the host group behind each — name, date, online/in-person, venue + geo, fee, RSVP/going count, and the group's member count, location & topics. Optionally enrich each group with a business contact email (billed per email found). One row per event. JSON/CSV.",
        "version": "0.0",
        "x-build-id": "ybC3XnGB8DXvBA3So"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~meetup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-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/memo23~meetup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-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/memo23~meetup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-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": {
                    "startUrls": {
                        "title": "Meetup URLs",
                        "type": "array",
                        "description": "Full Meetup URLs to crawl. Mix find, group, and event URLs in the same array if useful.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Free-text keyword for the Meetup find page (used only when no Start URLs are given). E.g. `technology`, `yoga`, `startup`."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Meetup location token used to build a find search (used only when no Start URLs are given). Tip: run a search on meetup.com and copy the `location=` value from the URL, e.g. `us--ny--New_York`."
                    },
                    "monitoringMode": {
                        "title": "Monitoring mode (only return events not seen on previous runs)",
                        "type": "boolean",
                        "description": "When enabled, events whose ID has already been delivered to you are silently skipped (no detail page is fetched, no charge applies). The first run after enabling monitoring returns every match — that builds your baseline. Every subsequent run returns only new events.",
                        "default": false
                    },
                    "resetMonitoringState": {
                        "title": "Reset monitoring state (one-shot)",
                        "type": "boolean",
                        "description": "One-shot toggle: clear the saved 'events already seen' record at the start of this run. Has no effect when monitoring mode is off.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum events to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of events collected across all start URLs. Use this to control billing.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of event pages processed in parallel.",
                        "default": 10
                    },
                    "minConcurrency": {
                        "title": "Min concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Minimum number of event pages processed in parallel.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of retries before a failed request is given up.",
                        "default": 5
                    },
                    "enrichEmails": {
                        "title": "Enrich with contact emails (experimental)",
                        "type": "boolean",
                        "description": "If enabled, finds a contact email for each result from its own website (or by discovering it from the name). Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Meetup has no aggressive anti-bot, so a small residential pool (or even datacenter) works fine.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```