# Facebook Events Scraper (`automation-lab/facebook-events-scraper`) Actor

📅 Extract public Facebook events from direct URLs: schedules, venues, organizers, attendance, descriptions, tickets, images, and status. No Facebook login required. Export or monitor through API and schedules.

- **URL**: https://apify.com/automation-lab/facebook-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **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

Facebook Events Scraper turns batches of **direct public Facebook event URLs** into structured, export-ready records.

Extract event names, schedules, venues, addresses, coordinates, descriptions, organizers, attendance counts, categories, tickets, images, and status without a Facebook login.

Use it for scheduled event monitoring, event aggregation, tourism research, promoter tracking, or data pipelines. Add one known event URL to try it in under two minutes.

> This Actor extracts direct public event pages. It does not search Facebook, access private events, identify attendees, or bypass login permissions.

### What does Facebook Events Scraper do?

Facebook Events Scraper opens each supplied public event page in a real browser and converts Facebook's page data into a stable dataset row.

It uses structured page state first, then fills gaps from Open Graph metadata and visible labels. This makes the output more reliable than copying rendered text alone.

Key capabilities include:

- 📅 batch extraction from direct event URLs
- 🕐 normalized start and end timestamps
- 📍 venue, address, city, and coordinates
- 👥 organizer names and profile URLs
- 📊 going, interested, and responded counts when public
- 📝 full public description, category, duration, and privacy label
- 🎟️ ticket URL and event image when available
- 🔁 bounded retries and per-URL error diagnostics
- 📦 JSON, CSV, Excel, XML, and API exports through Apify

### Who is it for?

**Event aggregators and calendar publishers**

- Refresh known Facebook event pages on a schedule.
- Normalize dates, locations, hosts, and ticket links into one schema.
- Detect cancellations or changed event details in downstream systems.

**Venues, promoters, and tourism teams**

- Track public events at venues and destinations they manage.
- Maintain internal calendars without manual copy-and-paste work.
- Compare public response counts across promoted events.

**Local media and market researchers**

- Collect repeatable evidence about public cultural and community events.
- Build city-level event datasets from an approved URL list.
- Export event records to spreadsheets or analytics tools.

**Developers and automation teams**

- Call a stable Actor API instead of maintaining browser automation.
- Send records to databases, webhooks, Make, Zapier, or custom services.
- Use the Actor from AI agents through Apify MCP.

### Why use this Facebook event extractor?

- ✅ **No Facebook login required** for supported public event pages.
- ✅ **Strict scope validation** rejects search and non-event URLs before browser work starts.
- ✅ **Typed records** provide numbers as numbers and dates as ISO timestamps.
- ✅ **Batch ready** processes multiple known event URLs in one run.
- ✅ **Monitoring friendly** includes canonical URL, source URL, status flags, and scrape timestamp.
- ✅ **Cost controlled** blocks images, media, fonts, and stylesheets during extraction.
- ✅ **Explicit failures** writes failed URL details to the `ERRORS` key-value-store record.
- ✅ **Apify-native** supports scheduling, API access, webhooks, datasets, and integrations.

### What Facebook event data can you extract?

| Category | Fields |
|---|---|
| Identity | `eventId`, `url`, `sourceUrl`, `name` |
| Schedule | `dateText`, `startDate`, `endDate`, `timezone`, `durationText` |
| Location | `venueName`, `venueUrl`, `address`, `city`, `latitude`, `longitude` |
| Content | `description`, `category`, `privacy`, `imageUrl`, `ticketUrl` |
| Organizers | `organizerNames`, `organizerUrls` |
| Attendance | `goingCount`, `interestedCount`, `respondedCount` |
| State | `isOnline`, `isPast`, `isCanceled` |
| Provenance | `scrapedAt` |

Facebook does not expose every field on every public event. Optional fields are omitted when they are not present rather than filled with invented values.

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

This Actor uses **pay-per-event pricing**. You pay a small run-start fee plus one charge for each event record saved.

Current pricing is:

| Charge | Free | Starter / Bronze | Scale / Silver | Business / Gold |
|---|---:|---:|---:|---:|
| Run start | $0.035 | $0.035 | $0.035 | $0.035 |
| Event extracted | $0.0031407 | $0.0027311 | $0.0021302 | $0.0016386 |

Examples at the Bronze rate:

| Workflow | Events | Estimated total charge |
|---|---:|---:|
| Check one event | 1 | ~$0.0377 |
| Refresh a venue calendar | 25 | ~$0.1033 |
| Monitor an event portfolio | 100 | ~$0.3081 |

Apify platform compute and proxy use are included in pay-per-event billing. The prices were formula-validated against both direct-cloud and residential-fallback runs.

### How to scrape public Facebook event pages

1. Open **Facebook Events Scraper** in the Apify Store.
2. Copy direct public event URLs from Facebook.
3. Add the URLs to **Facebook event URLs**.
4. Keep **Maximum events** low for the first run.
5. Leave the residential fallback enabled for recovery if direct cloud access is blocked.
6. Click **Start** and wait for the dataset preview.
7. Export the results or connect a webhook, schedule, or API client.

A supported URL contains a numeric event ID, for example:

```text
https://www.facebook.com/events/1023978871819924/
````

A search URL such as `facebook.com/events/search/...` is intentionally rejected.

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | required | Direct public Facebook event URLs |
| `maxEvents` | integer | `10` | Maximum unique events processed, from 1 to 100 |
| `proxyConfiguration` | object | Apify Residential | Proxy settings used only on a retry after direct access fails |
| `maxRetries` | integer | `1` | Retries per event after a blocked or incomplete page, from 0 to 2 |

Minimal input:

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/events/1023978871819924/" }
  ],
  "maxEvents": 1,
  "maxRetries": 1
}
```

Batch monitoring input:

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/events/1614250356703863/" },
    { "url": "https://www.facebook.com/events/2798221353873846/" },
    { "url": "https://www.facebook.com/events/1314602867488527/" }
  ],
  "maxEvents": 3,
  "maxRetries": 1
}
```

### Facebook event output example

```json
{
  "eventId": "1023978871819924",
  "url": "https://www.facebook.com/events/accor-stadium/red-hot-chili-peppers-with-post-malone-sydney/1023978871819924/",
  "sourceUrl": "https://www.facebook.com/events/1023978871819924/",
  "name": "Red Hot Chili Peppers with Post Malone | Sydney",
  "dateText": "Thursday, February 2, 2023 at 8:00 PM – 12:00 AM AEDT",
  "startDate": "2023-02-02T09:00:00.000Z",
  "endDate": "2023-02-02T13:00:00.000Z",
  "timezone": "UTC+11",
  "venueName": "Accor Stadium",
  "address": "Edwin Flack Avenue Sydney Olympic Park NSW, 2127",
  "city": "Sydney, Australia",
  "latitude": -33.84726902893,
  "longitude": 151.06334209442,
  "organizerNames": ["Live Nation Australia", "Post Malone", "Red Hot Chili Peppers"],
  "goingCount": 4500,
  "interestedCount": 12000,
  "respondedCount": 17500,
  "durationText": "4 hr",
  "privacy": "Public",
  "category": "Music",
  "isOnline": false,
  "isPast": true,
  "scrapedAt": "2026-07-16T00:00:00.000Z"
}
```

Output is stored in the default Apify dataset. Failed URLs are stored separately in the `ERRORS` key-value-store record so event rows keep one consistent schema.

### Tips for reliable Facebook event extraction

- Start with one known public event URL before running a larger batch.
- Use canonical event links with a numeric event ID.
- Keep the residential proxy enabled on cloud runs.
- Schedule modest batches instead of repeatedly scraping the same page every few minutes.
- Treat attendance counts as snapshots; Facebook can round values such as `17.5K`.
- Preserve `eventId` as your stable deduplication key.
- Compare `scrapedAt` and status fields when building change detection.
- Check the `ERRORS` record when some URLs do not produce rows.

### Monitoring public Facebook events

For repeat monitoring, create an Apify schedule with the same URL batch and send each completed dataset to a webhook.

A typical change-detection workflow is:

1. Run the Actor daily.
2. Store records keyed by `eventId`.
3. Compare dates, venue, ticket URL, attendance, and cancellation status.
4. Notify your team only when selected fields change.

This pattern avoids relying on Facebook search and keeps your source list explicit and auditable.

### Integrations

**Facebook Events Scraper → Google Sheets**

Append a daily snapshot of public event dates, venues, and response counts for editorial or tourism planning.

**Facebook Events Scraper → Slack or Discord**

Send an alert when an event becomes canceled, changes venue, or receives a sharp increase in public responses.

**Facebook Events Scraper → Make or Zapier**

Trigger a workflow after each run, filter new event IDs, and create calendar or CRM records.

**Facebook Events Scraper → database**

Use `eventId` as the primary key and retain historical snapshots for trend analysis.

**Facebook Events Scraper → webhooks**

Push completed-run metadata to your own service for immediate downstream processing.

### API usage with Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/facebook-events-scraper').call({
  startUrls: [{ url: 'https://www.facebook.com/events/1023978871819924/' }],
  maxEvents: 1,
  maxRetries: 1,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/facebook-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.facebook.com/events/1023978871819924/'}],
    'maxEvents': 1,
    'maxRetries': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~facebook-events-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.facebook.com/events/1023978871819924/"}],
    "maxEvents": 1,
    "maxRetries": 1
  }'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use Facebook Events Scraper with AI agents via MCP

Facebook Events Scraper can be called by AI assistants through the [Apify MCP integration](https://docs.apify.com/platform/integrations/mcp).

For Claude Code:

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

For Claude Desktop, Cursor, or VS Code, add:

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

Example prompts:

- “Use `automation-lab/facebook-events-scraper` to extract these five public Facebook event links and summarize date conflicts.”
- “Refresh my known venue event URLs and flag cancellations or venue changes.”
- “Export organizer, location, attendance, and ticket fields from these public Facebook events.”

### Supported and unsupported Facebook URLs

Supported:

- direct public event URLs with numeric event IDs
- canonical event URLs that include a venue or event slug before the numeric ID
- `www.facebook.com` and `m.facebook.com` event links

Not supported:

- event search and explore URLs
- private, invite-only, deleted, or login-only events
- Facebook groups, pages, profiles, posts, or discussions
- attendee identities or guest lists
- keyword, category, or location discovery

### Error handling

One inaccessible URL does not discard valid sibling events. The Actor records the URL, event ID, number of attempts, and final error in `ERRORS`.

If every requested URL fails, the run exits non-zero instead of reporting a misleading success with an empty dataset.

Common failure messages distinguish invalid input, HTTP errors, login/private/deleted pages, and pages with no extractable public event record.

### Legality: is it legal to scrape public Facebook events?

Scraping publicly accessible information can be lawful, but the rules depend on your jurisdiction, purpose, and the data you process.

Use this Actor only for public event pages you are authorized to collect. Respect Facebook's terms, intellectual-property rights, applicable privacy law, and reasonable request rates. Do not use output for harassment, sensitive profiling, or attempts to identify attendees.

If you process personal data, establish a lawful basis, minimize retention, honor deletion requests, and follow GDPR, CCPA, or other applicable requirements. This documentation is not legal advice.

### FAQ

**Does Facebook Events Scraper require a Facebook account?**

No. It extracts only event details visible on public Facebook event pages without login.

**Can it search Facebook events by keyword or city?**

No. v1 deliberately accepts direct event URLs only. It does not promise Facebook search discovery.

**How fast is it?**

A one-event run typically completes in under two minutes. Browser startup, proxy routing, page complexity, and retries affect duration.

**Why is the output empty for one URL?**

The event may be private, deleted, login-only, blocked, or not a direct event URL. Review the run log and the `ERRORS` key-value-store record.

**Why are some fields missing?**

Facebook does not expose every field for every event. Online events may not have coordinates, free events may not have tickets, and hosts can hide selected details.

**Why do attendance numbers differ from the displayed abbreviation?**

Facebook sometimes displays rounded values such as `12K` or `17.5K`. The Actor converts those public abbreviations into approximate integers.

**How much does a run cost?**

You pay a small start fee plus one event charge per dataset row. Higher Apify plans receive volume discounts.

**How does this compare with Facebook's official API?**

This Actor is designed for direct public web event URLs and requires no app review or access token. It is not a replacement for authenticated Meta APIs or private data access.

### Related social media scrapers

Extend public social-media workflows with other Automation Lab Actors:

- [Facebook Pages Scraper](https://apify.com/automation-lab/facebook-pages-scraper)
- [Facebook Video Search Scraper](https://apify.com/automation-lab/facebook-video-search-scraper)
- [Instagram Scraper](https://apify.com/automation-lab/instagram-scraper)
- [TikTok Search Scraper](https://apify.com/automation-lab/tiktok-search-scraper)
- [YouTube Channel Scraper](https://apify.com/automation-lab/youtube-channel-scraper)
- [LinkedIn Post Scraper](https://apify.com/automation-lab/linkedin-post-scraper)
- [Threads Scraper](https://apify.com/automation-lab/threads-scraper)
- [Reddit Scraper](https://apify.com/automation-lab/reddit-scraper)

### Limitations and data freshness

Facebook can change page structures, rounded attendance values, localization, and anonymous visibility without notice.

The Actor records what was publicly visible at `scrapedAt`. It does not guarantee that an event remains public or unchanged after extraction.

For dependable monitoring, use scheduled runs, keep batches bounded, and retain source URLs plus historical snapshots.

# Actor input Schema

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

Add direct public Facebook event links such as https://www.facebook.com/events/1023978871819924/. Search and explore URLs are rejected.

## `maxEvents` (type: `integer`):

Limit the number of unique event URLs processed in this run.

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

Configure the proxy used only as a fallback after direct public access fails. Residential sessions improve recovery from cloud-IP blocks.

## `maxRetries` (type: `integer`):

Retry a blocked or incomplete event with a fresh browser/proxy session. Keep this low to control cost.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/events/1023978871819924/"
    }
  ],
  "maxEvents": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRetries": 1
}
```

# 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://www.facebook.com/events/1023978871819924/"
        }
    ],
    "maxEvents": 1,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "maxRetries": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/facebook-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://www.facebook.com/events/1023978871819924/" }],
    "maxEvents": 1,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "maxRetries": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/facebook-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://www.facebook.com/events/1023978871819924/"
    }
  ],
  "maxEvents": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxRetries": 1
}' |
apify call automation-lab/facebook-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Events Scraper",
        "description": "📅 Extract public Facebook events from direct URLs: schedules, venues, organizers, attendance, descriptions, tickets, images, and status. No Facebook login required. Export or monitor through API and schedules.",
        "version": "0.1",
        "x-build-id": "m7MCIhvJdeUhCc7du"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~facebook-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-facebook-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~facebook-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-facebook-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~facebook-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-facebook-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": "📅 Facebook event URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Add direct public Facebook event links such as https://www.facebook.com/events/1023978871819924/. Search and explore URLs are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxEvents": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Limit the number of unique event URLs processed in this run.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Configure the proxy used only as a fallback after direct public access fails. Residential sessions improve recovery from cloud-IP blocks.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxRetries": {
                        "title": "Retry blocked events",
                        "minimum": 0,
                        "maximum": 2,
                        "type": "integer",
                        "description": "Retry a blocked or incomplete event with a fresh browser/proxy session. Keep this low to control cost.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```