# Partiful Events Scraper (`automation-lab/partiful-events-scraper`) Actor

🎟️ Extract public Partiful events with schedules, venues, hosts, images, maps, and visible attendance signals from Explore and event pages.

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

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Partiful Events Scraper

Turn public Partiful city calendars and event pages into clean, structured event data. Collect titles, schedules, venues, hosts, cover images, map links, and attendance signals without logging in.

Use the results for event discovery, local market research, community intelligence, lead generation, or recurring calendar monitoring. The Actor uses lightweight HTTP requests, deduplicates events by ID, and supports optional detail enrichment.

### What does Partiful Events Scraper do?

- Discovers public events from Partiful Explore city pages.
- Extracts one specific public event from an event URL.
- Returns event dates with the source timezone.
- Captures venues, addresses, neighborhoods, and Google Maps links.
- Exports interested, going, approved, maybe, and waitlist counts when Partiful exposes them.
- Optionally visits each detail page for more complete records.
- Deduplicates events found in more than one source.

### Who is it for?

**Event marketers** can identify active communities and upcoming sponsorship opportunities.

**Local lead-generation teams** can build prospect lists of event hosts and venues.

**Event aggregators** can refresh Partiful listings on a schedule.

**Community intelligence teams** can compare event activity and visible attendance across cities.

**Researchers and developers** can consume normalized Partiful event JSON instead of maintaining a parser.

### Why use this Partiful event extractor?

Partiful pages are designed for people, not spreadsheets. This Actor converts embedded public page data into stable dataset rows that can be exported to JSON, CSV, Excel, XML, RSS, or Parquet.

HTTP-first extraction keeps runs fast and inexpensive. A single run can combine Explore and event URLs while event-ID deduplication prevents duplicate records.

### What Partiful event data can I extract?

| Field | Meaning |
|---|---|
| `eventId` | Stable Partiful event ID |
| `url` | Canonical public event URL |
| `eventTitle` | Event title |
| `eventDescription` | Public event description |
| `startDate`, `endDate` | ISO schedule values |
| `timezone` | Event timezone |
| `venueName`, `address` | Venue and formatted address |
| `neighborhood` | Neighborhood when available |
| `googleMapsUrl` | Direct map search link |
| `hostName`, `hostIds` | Public host information |
| `imageUrl` | Cover image URL |
| guest count fields | Visible attendance breakdowns |
| `status`, `isPublic` | Publication state |
| `sourceUrl`, `scrapedAt` | Provenance and freshness |

Optional fields are omitted when Partiful does not expose them.

### How much does it cost to scrape Partiful events?

The Actor uses pay-per-event pricing: a small start charge plus a charge for each saved event. The BRONZE rate is $0.000028634 per event, with automatic volume discounts on higher Apify plans. Final live prices are displayed before every run.

You pay for records saved, not pages with no usable event data. Leave detail enrichment disabled for the cheapest discovery workflow.

### Quick start

1. Open the Actor input page.
2. Keep the prefilled NYC Explore URL or add your own Partiful URLs.
3. Choose a maximum number of events.
4. Enable detail enrichment only if needed.
5. Click **Start**.
6. Export the resulting dataset in your preferred format.

### Input

```json
{
  "startUrls": [
    { "url": "https://partiful.com/explore/nyc" },
    { "url": "https://partiful.com/e/x82ndPsPYCo1qWGuSMUo" }
  ],
  "maxItems": 100,
  "enrichDetails": false
}
````

`startUrls` accepts Partiful `/explore/{city}` and `/e/{eventId}` URLs. `maxItems` is a run-wide unique-event limit from 1 to 10,000.

### Discovery versus detail enrichment

Explore pages already expose useful event fields and are the recommended low-cost mode. Set `enrichDetails` to `true` when detail pages may contain richer descriptions or locations.

If one detail request fails, the Actor logs a warning and keeps the discovery record. This makes scheduled collection resilient to isolated event-page changes.

### Output example

```json
{
  "eventId": "x82ndPsPYCo1qWGuSMUo",
  "url": "https://partiful.com/e/x82ndPsPYCo1qWGuSMUo",
  "eventTitle": "Abbode Sample Sale",
  "eventDescription": "Shop the latest collection at this public sample sale.",
  "startDate": "2026-07-15T15:00:00.000Z",
  "timezone": "America/New_York",
  "address": "108 Madison St, New York, NY 10002",
  "isPublic": true,
  "sourceUrl": "https://partiful.com/e/x82ndPsPYCo1qWGuSMUo",
  "scrapedAt": "2026-07-13T00:00:00.000Z"
}
```

### Scheduling and monitoring

Create an Apify schedule to refresh city calendars daily or weekly. Store each run in a downstream database and compare event IDs, dates, status, or guest counts to detect additions and changes.

For stable monitoring, keep the same source URLs and avoid changing enrichment settings between runs.

### Event lead-generation workflow

1. Scrape one or more city Explore pages.
2. Filter upcoming events by neighborhood or attendance.
3. Review venue and public host fields.
4. Enrich only shortlisted event URLs.
5. Send qualified records to a CRM or spreadsheet.

Public event data is not consent to contact people. Apply your own legal basis and outreach rules.

### Integrations

Connect datasets to **Google Sheets** for editorial calendars, **Airtable** for event operations, **Make** or **Zapier** for notifications, and **Slack** for daily digests.

Use Apify webhooks to trigger a workflow when a run succeeds. Use dataset API endpoints to load records into warehouses, BI tools, or custom event products.

### API usage

Run the Actor from JavaScript, Python, cURL, the Apify Console, or MCP. The API examples below use the stable `automation-lab/partiful-events-scraper` identifier.

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/partiful-events-scraper').call({
  startUrls: [{ url: 'https://partiful.com/explore/nyc' }],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/partiful-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://partiful.com/explore/nyc'}],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

### cURL API example

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~partiful-events-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://partiful.com/explore/nyc"}],"maxItems":100}'
```

Poll the returned run ID or use an Apify webhook, then fetch items from the run's default dataset.

### Use with Apify MCP

Connect AI assistants through this actor-specific Streamable HTTP endpoint:

`https://mcp.apify.com?tools=automation-lab/partiful-events-scraper`

For **Claude Code**, register it from a terminal:

```bash
claude mcp add --transport http partiful-events "https://mcp.apify.com?tools=automation-lab/partiful-events-scraper"
```

For **Claude Desktop**, open **Settings → Connectors → Add custom connector**, paste the endpoint above, and complete the Apify sign-in. For Claude Desktop installations that expose JSON configuration, **Cursor** (`.cursor/mcp.json`), or **VS Code** (`mcp.json`), use:

```json
{
  "mcpServers": {
    "partiful-events": {
      "url": "https://mcp.apify.com?tools=automation-lab/partiful-events-scraper"
    }
  }
}
```

Restart the client after saving the JSON. The first connection opens Apify authentication; approve it before running the Actor.

Example prompts:

- “Find upcoming public Partiful events in NYC and group them by neighborhood.”
- “Extract this Partiful event and summarize its schedule, venue, and visible demand.”
- “Compare visible attendance signals in this week's event dataset.”

### Tips for reliable runs

- Use canonical `https://partiful.com` URLs.
- Combine city pages when you need more than one local market.
- Keep enrichment off for broad discovery.
- Set `maxItems` close to the volume you actually need.
- Schedule moderate refresh intervals rather than repeatedly scraping unchanged pages.
- Preserve `eventId` as the primary key in downstream systems.

### Limitations

The Actor extracts public data embedded in Partiful pages. Private, invite-only, login-gated, or hidden guest information is not accessible.

Explore coverage and payload shape are controlled by Partiful and may change. A city Explore page can contain fewer events than `maxItems`. Guest counts appear only when the event exposes them.

The Actor does not RSVP, message hosts, bypass access controls, or retrieve private attendee identities.

### Legality

### Is it legal to scrape Partiful events?

Public event facts can often be collected for legitimate purposes, but laws and website terms vary by jurisdiction and use case. Only collect data you are authorized to use. Avoid personal-data profiling, spam, harassment, and attempts to access private events.

You are responsible for retention, outreach, privacy, and compliance decisions in downstream workflows.

### Troubleshooting

**Why did the run save fewer events than `maxItems`?** The source pages contained fewer unique public event IDs. Add another city Explore URL or event URLs.

**Why is a venue or count missing?** Partiful did not expose that optional value on the source page. Try detail enrichment.

**Why was my URL rejected?** Only Partiful Explore city and public event URL patterns are accepted. Remove tracking redirects and use the canonical URL.

**Why did a detail warning appear?** One enrichment request failed. The Actor keeps the discovery record rather than losing the event.

### FAQ

#### Does it require a Partiful account?

No. The Actor reads anonymously accessible public pages.

#### Can I scrape one event?

Yes. Provide its `/e/{id}` URL and set `maxItems` to 1.

#### Can I scrape multiple cities?

Yes. Add several Explore URLs to `startUrls`; duplicate events are merged by ID.

#### Does it reveal guest identities?

No. It exports public aggregate counts where available, not hidden attendee lists.

#### Can I export to Excel or CSV?

Yes. Use the dataset Export menu or API format parameter.

### Related scrapers

Explore more event and lead-generation tools from [Automation Labs](https://apify.com/automation-lab). Combine this Actor with public website contact extractors, geocoders, or calendar-processing Actors when those workflows have an appropriate legal basis.

### Support

If a valid public Partiful URL stops producing expected records, open an Actor issue with the URL, run ID, expected result, and a short description. Do not include private invitation links, credentials, or personal information.

# Actor input Schema

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

Partiful Explore city URLs or public event URLs.

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

Stop after saving this many unique public events.

## `enrichDetails` (type: `boolean`):

Visit each event page to fill fields not present on Explore pages. Slower but more complete.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://partiful.com/explore/nyc"
    }
  ],
  "maxItems": 20,
  "enrichDetails": false
}
```

# Actor output Schema

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

No description

# 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": [
        {
            "url": "https://partiful.com/explore/nyc"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/partiful-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 = {
    "startUrls": [{ "url": "https://partiful.com/explore/nyc" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/partiful-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 '{
  "startUrls": [
    {
      "url": "https://partiful.com/explore/nyc"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/partiful-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Partiful Events Scraper",
        "description": "🎟️ Extract public Partiful events with schedules, venues, hosts, images, maps, and visible attendance signals from Explore and event pages.",
        "version": "0.1",
        "x-build-id": "3WdF2jhq3EpvddczA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~partiful-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-partiful-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/automation-lab~partiful-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-partiful-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/automation-lab~partiful-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-partiful-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🎟️ Partiful URLs",
                        "type": "array",
                        "description": "Partiful Explore city URLs or public event URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many unique public events.",
                        "default": 20
                    },
                    "enrichDetails": {
                        "title": "Enrich event details",
                        "type": "boolean",
                        "description": "Visit each event page to fill fields not present on Explore pages. Slower but more complete.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```