# WeddingWire Wedding Couple Scraper (`parseforge/weddingwire-couples-scraper`) Actor

Find couples on WeddingWire by name and collect their public wedding website. Every record returns both partners first and last names, the wedding date, days until the wedding, city and state, a welcome message, and a link to the couple website. Useful for enriching leads.

- **URL**: https://apify.com/parseforge/weddingwire-couples-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.52 / 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.
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.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 💍 WeddingWire Couples & Wedding Website Scraper

> 🚀 **Enrich a name into public wedding details in seconds.** Type a partner's name, get back the couple's public wedding-website details: both partners' names, wedding date, city and state, countdown, and the public website link. Up to 20 couples per search term.

> 🕒 **Last updated:** 2026-07-08 · **📊 14 fields** per record · Structured JSON/CSV/Excel/XML · Public WeddingWire wedding-website data only

This Actor is an **enrichment tool** for the public wedding-website data that couples themselves publish on WeddingWire. You provide a name (a first name, last name, or full name of one partner) and it returns the matching couples' publicly listed wedding-website details. It does not create or invent contact data, and it only reads information couples chose to make public in WeddingWire's open wedding-website directory.

**Coverage:** Each search term returns up to 20 public couples from WeddingWire's directory. Supply several names to cover more couples. Every record carries both partners' names (when the listing shows two), the wedding date and countdown, the couple's city and state, the public wedding-website URL, and the couple's cover photo when available.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Wedding vendors (venues, photographers, planners, caterers) | Confirm a couple's public wedding date and city before outreach |
| Registry and gifting services | Match a known couple to their public wedding website |
| Guests and family | Find a couple's public wedding website by name |
| Market researchers | Analyze aggregate public wedding timing and geography |

### 📋 What the WeddingWire Couples Scraper does

- Searches WeddingWire's **public** wedding-website directory by name.
- Returns up to **20 couples per search term**, each with structured fields.
- Parses the couple names into separate first and last names for both partners.
- Reads each couple's public wedding-website header for their **city and state** and welcome message.
- Outputs clean JSON, CSV, Excel, or XML you can pipe anywhere.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `mode` | select (`search` / `discover`) | No | Run mode. `search` (default) looks up names you provide. `discover` browses WeddingWire's public wedding-website directory with optional state and date filters. |
| `searchTerms` | array of strings | For `search` mode | One or more names to search (a partner's first name, last name, or full name). Each term returns up to 20 public couples. Applies to `search` mode. |
| `startWebId` | integer | No | Discover mode only. Optional website ID to start from. |
| `randomizeStart` | boolean | No | Discover mode only. When on (default), starts from a fresh point so each run surfaces different couples. |
| `usState` | string | No | Discover mode only. Two-letter US state filter, e.g. `FL`. |
| `weddingDateFrom` | string | No | Discover mode only. Earliest wedding date to include (YYYY-MM-DD). |
| `weddingDateTo` | string | No | Discover mode only. Latest wedding date to include (YYYY-MM-DD). |
| `maxScan` | integer | No | Discover mode only. Budget: the maximum number of directory IDs to walk in a run. |
| `maxItems` | integer | No | Cap on total records. Free plan is limited to 10. |
| `fetchDetails` | boolean | No | When on (default), also reads each couple's public website for the welcome message and any public location. Turn off for a faster, names-only run. |
| `onlyComplete` | boolean | No | Only complete leads. When on, keeps only couples that have a partner name and a wedding date; sparse records are skipped and counted in the run log rather than silently dropped. Off by default. |

**Example 1 - enrich a last name**
```json
{
    "searchTerms": ["Smith"],
    "maxItems": 5,
    "fetchDetails": true
}
````

**Example 2 - several names, names only**

```json
{
    "searchTerms": ["Garcia", "Nguyen", "Patel"],
    "maxItems": 60,
    "fetchDetails": false
}
```

> ⚠️ **Good to Know:** This Actor reads only publicly available wedding-website data that couples published on WeddingWire. It returns up to 20 couples per search term, and does **not** return venue, guest lists, RSVP data, or any private information. A couple's location appears only when the couple made it public.

### 🔀 Two modes

- **`search`** (default): look up a name you already have. Provide `searchTerms` and get back the matching couples' public wedding-website details. Best when you know who you're looking for.
- **`discover`**: no name needed. Walks WeddingWire's public wedding-website directory so you can browse it with optional `usState` and `weddingDateFrom` / `weddingDateTo` filters. It walks the newest public website IDs downward, so the most recent and upcoming weddings come back first. `randomizeStart` keeps runs fresh, and `maxScan` sets how many directory IDs a run is allowed to walk (your budget). `onlyComplete` pairs well with discover to drop sparse listings as you browse. Best when you have no name yet.

```json
{ "mode": "discover", "usState": "FL", "maxScan": 5000, "maxItems": 500 }
```

### 📊 Output

Each record contains the following fields:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Couple's public cover photo (when set) |
| 💑 `coupleNames` | Full couple names as published, e.g. "Dionna Smith & Reginald Smith Sr" |
| 🧑 `partner1FirstName` | First partner's first name |
| 🧑 `partner1LastName` | First partner's last name |
| 🧑 `partner2FirstName` | Second partner's first name (when listed) |
| 🧑 `partner2LastName` | Second partner's last name (when listed) |
| 📅 `weddingDate` | Wedding date (MM/DD/YYYY) |
| ⏳ `daysUntilWedding` | Days remaining until the wedding |
| 📍 `location` | Couple's public city and state |
| 💬 `welcomeMessage` | Couple's public welcome message |
| 🔗 `weddingWebsiteUrl` | Public wedding-website URL |
| 🆔 `webId` | WeddingWire website ID |
| 🔎 `searchTerm` | The search term that returned this record |
| 🕒 `scrapedAt` | Collection timestamp (ISO 8601) |

**Real sample records** (from a live `searchTerms: ["Smith"]` run):

```json
[
  {
    "imageUrl": "https://cdn0.weddingwire.com/user/9530/1_1/320/jpg/gu_37800359.jpeg",
    "coupleNames": "Dionna Smith & Reginald Smith Sr",
    "partner1FirstName": "Dionna",
    "partner1LastName": "Smith",
    "partner2FirstName": "Reginald",
    "partner2LastName": "Smith Sr",
    "weddingDate": "08/18/2029",
    "daysUntilWedding": 1136,
    "location": "Coon Rapids, Minnesota",
    "welcomeMessage": "We are getting married!",
    "weddingWebsiteUrl": "https://www.weddingwire.us/website/W37800359",
    "webId": "W37800359",
    "searchTerm": "Smith",
    "scrapedAt": "2026-07-08T19:03:17.266Z",
    "error": null
  },
  {
    "imageUrl": null,
    "coupleNames": "Cameron Smith",
    "partner1FirstName": "Cameron",
    "partner1LastName": "Smith",
    "partner2FirstName": null,
    "partner2LastName": null,
    "weddingDate": "11/01/2027",
    "daysUntilWedding": 480,
    "location": "West Chester, Pennsylvania",
    "welcomeMessage": "We are getting married!",
    "weddingWebsiteUrl": "https://www.weddingwire.us/website/W43768094",
    "webId": "W43768094",
    "searchTerm": "Smith",
    "scrapedAt": "2026-07-08T19:03:17.429Z",
    "error": null
  },
  {
    "imageUrl": "https://cdn0.weddingwire.com/user/8859/1_1/320/jpg/gu_45369588.jpeg",
    "coupleNames": "Madeline Smith & Madeline Smith",
    "partner1FirstName": "Madeline",
    "partner1LastName": "Smith",
    "partner2FirstName": "Madeline",
    "partner2LastName": "Smith",
    "weddingDate": "06/27/2027",
    "daysUntilWedding": 353,
    "location": "Indianapolis, Indiana",
    "welcomeMessage": "We are getting married!",
    "weddingWebsiteUrl": "https://www.weddingwire.us/website/W45369588",
    "webId": "W45369588",
    "searchTerm": "Smith",
    "scrapedAt": "2026-07-08T19:03:17.557Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

- **Structured output.** Couple names are pre-split into first and last for both partners.
- **Public data only.** Reads WeddingWire's open wedding-website directory, no login.
- **Honest scope.** Returns exactly what is public: names, date, city and state, website link.
- **Fast.** A five-record enrichment finishes in a few seconds.
- **Any format.** JSON, CSV, Excel, or XML.

### 📈 How it compares to alternatives

| Approach | Setup | Structured fields | Public-only | Maintenance |
|---|---|---|---|---|
| Manual directory lookup | None | No | Yes | High effort per name |
| Generic HTML scraper | High | No | Depends | You maintain parsers |
| **This Actor** | Minutes | Yes | Yes | Managed for you |

### 🚀 How to use

1. Create a free Apify account at <https://console.apify.com/sign-up?fpr=vmoqkp>.
2. Open the WeddingWire Couples & Wedding Website Scraper.
3. Enter one or more names in `searchTerms`.
4. Set `maxItems` and choose whether to `fetchDetails`.
5. Run the Actor and export results as JSON, CSV, Excel, or XML.

### 💼 Business use cases

| Wedding vendors | Registry & gifting |
|---|---|
| Verify a couple's public date and city before a personalized pitch. | Match a known couple to their public wedding website and registry link. |

| Market research | Guests & family |
|---|---|
| Study aggregate public wedding timing and geography by name cohort. | Locate a couple's public wedding website when you only know a name. |

### 🔌 Automating WeddingWire Couples Scraper

Connect runs and datasets to Make, Zapier, Slack, Airbyte, GitHub, and Google Drive through Apify's integrations to push new records into your CRM, spreadsheet, or messaging channel automatically.

### 🌟 Beyond business use cases

- **Research:** aggregate public wedding-date and location trends.
- **Personal:** find a friend or relative's public wedding website by name.
- **Non-profit:** understand seasonal wedding geography for community planning.
- **Experimentation:** learn structured web-data extraction with a clean, public dataset.

### 🤖 Ask an AI assistant

Paste your exported dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize wedding timing, group couples by state, or draft personalized outreach.

### ❓ Frequently Asked Questions

**Is this only public data?** Yes. It reads WeddingWire's open wedding-website directory, which couples chose to make public. No login, no private data.

**Does it return the venue?** No. Venue, guest lists, and RSVP details are not available through the public directory, so they are not returned.

**What fields do I get?** Both partners' names (split into first and last), wedding date, days until the wedding, city and state, welcome message, public website URL, website ID, and a cover photo when available.

**How many couples per search?** Up to 20 per search term. Add more terms to cover more couples.

**Can it find a couple with no name?** Yes, with the optional `discover` mode. It browses WeddingWire's public wedding-website directory with state and date filters, so no name is required. It still reads only public pages and does not sell or provide contact data. Use the default `search` mode when you already have a name.

**Why is `location` sometimes empty?** The city and state appear only when the couple made them public on their website.

**Why is `partner2` sometimes empty?** Some listings show only one partner's name.

**What formats can I export?** JSON, CSV, Excel, and XML.

**Does the free plan work?** Yes, limited to 10 records per run.

**Is this affiliated with WeddingWire?** No. It is an independent tool that reads only publicly available data.

### 🔌 Integrate with any app

Every run writes to an Apify dataset you can pull via API, webhook, or scheduled export into your own systems.

### 🔗 Recommended Actors

- Registry and gifting data enrichment Actors from ParseForge
- Directory and listing enrichment Actors from ParseForge
- Contact and profile enrichment Actors from ParseForge

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with WeddingWire. Only publicly available data collected.

# Actor input Schema

## `mode` (type: `string`):

How to collect couples. 'Search by name' enriches specific names you provide. 'Discover by ID walk' walks WeddingWire's sequential public website IDs to collect couples without needing any name.

## `searchTerms` (type: `array`):

Used in 'Search by name' mode. One or more names to search WeddingWire's public couple directory (a partner's first name, last name, or full name, e.g. Smith, Garcia, Sarah). Each term returns up to 20 public couples.

## `startWebId` (type: `integer`):

Used in 'Discover by ID walk' mode. Walk website IDs DOWNWARD from this number (newest weddings first); leave blank to start near the live frontier each run; the freshest upcoming weddings sit roughly in the 42,000,000-46,000,000 band.

## `randomizeStart` (type: `boolean`):

Discover mode only. When on (default) and no Start Website ID is given, pick a random starting point in the fresh 42,000,000-46,000,000 band each run, so repeated runs return different couples. Ignored when Start Website ID is set.

## `usState` (type: `string`):

Discover mode only. Keep only couples whose public location is in this US state (full name like 'Texas' or 2-letter code like 'TX'). Couples with no public location cannot be matched and are skipped when this filter is set.

## `weddingDateFrom` (type: `string`):

Discover mode only. Keep only couples whose wedding date is on or after this date (ISO YYYY-MM-DD).

## `weddingDateTo` (type: `string`):

Discover mode only. Keep only couples whose wedding date is on or before this date (ISO YYYY-MM-DD).

## `maxScan` (type: `integer`):

Discover mode only. Hard cap on how many website IDs to walk in one run, so a narrow filter cannot walk forever. The run stops at whichever comes first: Max Items matches or this scan budget.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `fetchDetails` (type: `boolean`):

In 'Search by name' mode, also opens each couple's public wedding website to capture location (city/state) and their welcome message. Disable for a faster, names-only run. Discover mode always reads the website page.

## `onlyComplete` (type: `boolean`):

When enabled, keeps only couples that have a partner name and a wedding date. Skips sparse records instead of returning them with blank fields. Skipped couples are counted in the log, not silently dropped.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "Smith"
  ],
  "randomizeStart": true,
  "maxScan": 3000,
  "maxItems": 10,
  "fetchDetails": true,
  "onlyComplete": false
}
```

# Actor output Schema

## `results` (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 = {
    "searchTerms": [
        "Smith"
    ],
    "maxScan": 3000,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/weddingwire-couples-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 = {
    "searchTerms": ["Smith"],
    "maxScan": 3000,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/weddingwire-couples-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 '{
  "searchTerms": [
    "Smith"
  ],
  "maxScan": 3000,
  "maxItems": 10
}' |
apify call parseforge/weddingwire-couples-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WeddingWire Wedding Couple Scraper",
        "description": "Find couples on WeddingWire by name and collect their public wedding website. Every record returns both partners first and last names, the wedding date, days until the wedding, city and state, a welcome message, and a link to the couple website. Useful for enriching leads.",
        "version": "0.1",
        "x-build-id": "B2E4qtZmkJM9FQAO3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~weddingwire-couples-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-weddingwire-couples-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/parseforge~weddingwire-couples-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-weddingwire-couples-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/parseforge~weddingwire-couples-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-weddingwire-couples-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "discover"
                        ],
                        "type": "string",
                        "description": "How to collect couples. 'Search by name' enriches specific names you provide. 'Discover by ID walk' walks WeddingWire's sequential public website IDs to collect couples without needing any name.",
                        "default": "search"
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Used in 'Search by name' mode. One or more names to search WeddingWire's public couple directory (a partner's first name, last name, or full name, e.g. Smith, Garcia, Sarah). Each term returns up to 20 public couples.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startWebId": {
                        "title": "Start Website ID",
                        "minimum": 1,
                        "maximum": 99999999,
                        "type": "integer",
                        "description": "Used in 'Discover by ID walk' mode. Walk website IDs DOWNWARD from this number (newest weddings first); leave blank to start near the live frontier each run; the freshest upcoming weddings sit roughly in the 42,000,000-46,000,000 band."
                    },
                    "randomizeStart": {
                        "title": "Randomize Start",
                        "type": "boolean",
                        "description": "Discover mode only. When on (default) and no Start Website ID is given, pick a random starting point in the fresh 42,000,000-46,000,000 band each run, so repeated runs return different couples. Ignored when Start Website ID is set.",
                        "default": true
                    },
                    "usState": {
                        "title": "US State Filter",
                        "type": "string",
                        "description": "Discover mode only. Keep only couples whose public location is in this US state (full name like 'Texas' or 2-letter code like 'TX'). Couples with no public location cannot be matched and are skipped when this filter is set."
                    },
                    "weddingDateFrom": {
                        "title": "Wedding Date From",
                        "type": "string",
                        "description": "Discover mode only. Keep only couples whose wedding date is on or after this date (ISO YYYY-MM-DD)."
                    },
                    "weddingDateTo": {
                        "title": "Wedding Date To",
                        "type": "string",
                        "description": "Discover mode only. Keep only couples whose wedding date is on or before this date (ISO YYYY-MM-DD)."
                    },
                    "maxScan": {
                        "title": "Max IDs to Scan",
                        "minimum": 1,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Discover mode only. Hard cap on how many website IDs to walk in one run, so a narrow filter cannot walk forever. The run stops at whichever comes first: Max Items matches or this scan budget."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "fetchDetails": {
                        "title": "Fetch Website Details",
                        "type": "boolean",
                        "description": "In 'Search by name' mode, also opens each couple's public wedding website to capture location (city/state) and their welcome message. Disable for a faster, names-only run. Discover mode always reads the website page.",
                        "default": true
                    },
                    "onlyComplete": {
                        "title": "Only complete leads",
                        "type": "boolean",
                        "description": "When enabled, keeps only couples that have a partner name and a wedding date. Skips sparse records instead of returning them with blank fields. Skipped couples are counted in the log, not silently dropped.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
