# Zola Wedding Couple and Venue Scraper (`parseforge/zola-couples-scraper`) Actor

Search Zola by a couple's names and pull their public wedding website. Every record returns both partners first and last names, the wedding date, city and state, the venue name and address, and links to the couple website and registry. Great for enriching wedding leads.

- **URL**: https://apify.com/parseforge/zola-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 $5.43 / 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)

## 💍 Zola Wedding Website & Couple Enrichment Scraper

> 🚀 **Turn a name into public wedding details in seconds.** Type a couple's name, get their public Zola wedding-website facts back: both partners' names, wedding date, city and state, venue, plus website and registry links. Up to 28 structured fields per couple, up to 50 matches per name.

> 🕒 **Last updated:** 2026-07-08 · **📊 Up to 28 fields** per record · **up to 50 couples per name query** · **US and international couples**

This Actor is an **enrichment tool** for information couples have **already chosen to publish** on their public Zola wedding website. You give it a name, it looks that name up in Zola's own public "Find a Couple" directory and returns the public details Zola already shows to any wedding guest: partner names, the wedding date, the location, and the venue. It does not invent lists of people and it never touches private, passcode-protected sites.

Couples print their Zola website URL on save-the-dates and invitations precisely so guests can find these details. This Actor reads that same public page and hands the facts to you as clean CSV, Excel, JSON, or XML instead of copy-paste.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Wedding vendors (venues, florists, photographers, planners) | Confirm and enrich a couple's public wedding details from a name |
| CRM and event teams | Fill in wedding date, city, and venue for a known lead |
| Registry and gifting services | Resolve a couple to their public registry and website link |
| Researchers and analysts | Study public wedding trends (dates, venues, locations) |

### 📋 What the Zola Wedding Website Scraper does

1. Takes one or more **names** you already have (a surname such as `smith`, or a partner's `first last`).
2. Queries Zola's public couple directory (the same search behind the "Find a Couple" page) and returns up to 50 matching public couples per name.
3. Optionally opens each couple's **public** wedding website and enriches the record with location, venue, split partner names, and the wedding headline.
4. Skips any passcode-protected (private) wedding site automatically. Only publicly visible data is collected.
5. Exports every record as CSV, Excel, JSON, or XML.

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

### ⚙️ Input

| Field | Key | Type | Required | Description |
|---|---|---|---|---|
| Mode | `mode` | select (`search`, `discover`) | ❌ No | How the run finds couples. `search` (default) looks up names you provide. `discover` browses Zola's public wedding directory. |
| Search Terms (couple names) | `searchTerms` | array of strings | ✅ In search mode | One or more names to look up. A surname or a partner's first + last name. Each term returns up to 50 public couples. Used in search mode. |
| US State | `usState` | string | ❌ No | Discover mode only. 2-letter state filter, for example `CA`, to limit the directory to one US state. |
| Wedding Date From | `weddingDateFrom` | string (`YYYY-MM-DD`) | ❌ No | Discover mode only. Only include couples with a public wedding date on or after this date. |
| Wedding Date To | `weddingDateTo` | string (`YYYY-MM-DD`) | ❌ No | Discover mode only. Only include couples with a public wedding date on or before this date. |
| Max Scan | `maxScan` | integer | ❌ No | Discover mode only. Cap on how many directory pages a run walks, so a run stays within a set budget and does not run too long. |
| Randomize Start | `randomizeStart` | boolean | ❌ No | Discover mode only. When on (default), the run starts from a random point in the directory so each run returns a fresh set of couples. |
| Max Items | `maxItems` | integer | ❌ No | Cap on records returned. Free plan is limited to 10. |
| Enrich with wedding-website details | `enrichDetails` | boolean | ❌ No | When on (default), opens each public wedding site for location, venue, split names, and headline. Turn off for a faster names-and-links-only run. |
| Only complete leads | `onlyComplete` | boolean | ❌ No | When on, returns only couples that have both names, a wedding date, and a city. Skips records with missing fields instead of returning blanks. |

**Example 1: enrich a single surname**
```json
{
  "searchTerms": ["haley"],
  "maxItems": 5,
  "enrichDetails": true
}
````

**Example 2: resolve several known names, links only (faster)**

```json
{
  "searchTerms": ["smith", "garcia", "nguyen"],
  "maxItems": 50,
  "enrichDetails": false
}
```

> ⚠️ **Good to Know:** This Actor enriches names you already hold. It matches against Zola's public directory, so a very common surname can return many unrelated couples. Use a first + last name to narrow results. Passcode-protected wedding sites are private and are skipped by design.

### 🔀 Two modes

The Actor can run in two ways, set by `mode`:

- **Search mode (default):** look up a name you already have. Provide `searchTerms` and the Actor resolves each name against Zola's public "Find a Couple" directory. This is the behavior described above.
- **Discover mode:** when you do not have a name yet, browse Zola's public wedding directory instead. Optional filters narrow the browse: `usState` (2-letter US state), plus `weddingDateFrom` and `weddingDateTo` for a date window. `maxScan` caps how many directory pages a run walks, and `randomizeStart` (on by default) starts from a random point so each run returns different couples. As in search mode, only publicly published pages are read and passcode-protected private sites are skipped. Turning on `onlyComplete` pairs well with discover mode, keeping only fully-populated leads that have both names, a wedding date, and a city.

```json
{"mode":"discover","usState":"CA","weddingDateFrom":"2026-01-01","weddingDateTo":"2026-12-31","maxScan":5000,"maxItems":500}
```

### 📊 Output

Each record contains up to 28 fields. Key fields:

| Field | Key | Description |
|---|---|---|
| 🖼 Image | `imageUrl` | Couple photo, when the couple made one public |
| 💍 Couple | `title` | Couple display title (for example "Morgan & Haley") |
| 🌐 Website | `weddingWebsiteUrl` | Public Zola wedding-website URL |
| 🎁 Registry | `registryUrl` | Public Zola registry URL |
| 👤 Owner First / Last | `ownerFirstName` / `ownerLastName` | First partner's name |
| 👥 Partner First / Last | `partnerFirstName` / `partnerLastName` | Second partner's name |
| 📅 Wedding Date | `weddingDate` | Wedding date (ISO, when public) |
| 🏙 City / State | `city` / `stateProvince` | Couple's stated location |
| 🏛 Venue | `venueName` | Venue name from the public schedule |
| 📍 Venue Address / City / State | `venueAddress` / `venueCity` / `venueState` | Venue location details |
| 🎉 Event | `eventName` | Public event name (Ceremony, Reception, and so on) |
| 👗 Attire | `attire` | Dress code, when published |
| 🗺 Map | `googleMapUrl` | Google Maps link to the venue |
| 🎁 Has Registry / 🌐 Has Website | `hasRegistry` / `hasWebsite` | Whether the couple published each |
| 🕒 Scraped | `scrapedAt` | Collection timestamp |
| ❌ Error | `error` | Null on success |

**3 real sample records** (from a live run on the name `haley`):

```json
{
  "imageUrl": "https://s3.amazonaws.com/registry-images/setzerbain/95134dc3-7c35-4db7-baa1-13e8656e780d.jpg",
  "title": "Morgan & Haley",
  "weddingWebsiteUrl": "https://www.zola.com/wedding/setzerbain",
  "registryUrl": "https://www.zola.com/registry/setzerbain",
  "ownerFirstName": "Morgan",
  "ownerLastName": "Setzer",
  "partnerFirstName": "Haley",
  "partnerLastName": "Bain",
  "weddingDate": "2027-09-24",
  "city": "Connemara",
  "stateProvince": "Ireland",
  "venueName": "Cashel House Hotel",
  "venueCity": "Cashel",
  "venueState": "County Galway",
  "eventName": "Ceremony & Reception",
  "hasRegistry": true,
  "hasWebsite": true
}
```

```json
{
  "title": "Bailey & Enrique",
  "weddingWebsiteUrl": "https://www.zola.com/wedding/haleysgethitched",
  "registryUrl": "https://www.zola.com/registry/haleysgethitched",
  "ownerFirstName": "Bailey",
  "ownerLastName": "Fabian",
  "partnerFirstName": "Enrique",
  "partnerLastName": "Haley",
  "weddingDate": "2027-06-18",
  "city": "Rockford",
  "stateProvince": "WA",
  "venueName": "The Greenhouse on Harvard",
  "venueAddress": "18602 S Harvard Rd",
  "venueCity": "Rockford",
  "venueState": "WA",
  "eventName": "Our Wedding",
  "weddingHeadline": "We're getting married!",
  "hasRegistry": true,
  "hasWebsite": true
}
```

```json
{
  "title": "Katelin & Dylan",
  "weddingWebsiteUrl": "https://www.zola.com/wedding/agnewhaleywedding",
  "registryUrl": "https://www.zola.com/registry/agnewhaleywedding",
  "ownerFirstName": "Katelin",
  "ownerLastName": "Agnew",
  "partnerFirstName": "Dylan",
  "partnerLastName": "Haley",
  "weddingDate": "2026-12-12",
  "city": "Martinsville",
  "stateProvince": "VA",
  "venueName": "The Legacy at Hatcher Farm",
  "venueAddress": "163 Hatcher Farm Rd",
  "venueCity": "Martinsville",
  "venueState": "VA",
  "eventName": "Ceremony",
  "attire": "Casual attire",
  "hasRegistry": true,
  "hasWebsite": true
}
```

### ✨ Why choose this Actor

- **Name in, facts out.** Built as an enrichment step: give it a name you already have, get the public wedding details back.
- **Clean, split fields.** Both partners' first and last names are separated, not a single blob.
- **Real venue data.** Venue name, address, city, state, and a Google Maps link straight from the couple's public schedule.
- **Public only.** Private, passcode-protected sites are detected and skipped. No logins, no paywalls.
- **Fast and light.** Runs on plain HTTP, no browser and no proxy needed, so runs are quick and cheap.
- **Any format.** CSV, Excel, JSON, or XML in one click.

### 📈 How it compares to alternatives

| Approach | Split partner names | Venue and location | Public-only, private skipped | Structured export |
|---|---|---|---|---|
| Manual copy-paste from a wedding site | Manual | Manual | You decide | ❌ |
| Generic HTML scraper | ❌ Usually one blob | Hit or miss | ❌ | Needs cleanup |
| **Zola Wedding Website Scraper** | ✅ | ✅ | ✅ Automatic | ✅ CSV/Excel/JSON/XML |

### 🚀 How to use

1. **Create a free Apify account** using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Zola Wedding Website & Couple Enrichment Scraper.
3. Enter one or more names under **Search Terms** (a surname, or a partner's first + last name).
4. Set **Max Items** and leave **Enrich with wedding-website details** on for full location and venue data.
5. Click **Start**, then download your results as CSV, Excel, JSON, or XML.

### 💼 Business use cases

#### Wedding venues and planners

| Goal | How this Actor helps |
|---|---|
| Confirm an inbound lead's date and city | Enrich the name they gave you into a public wedding date and location |
| Understand a couple's plans | See their public venue, event names, and attire |

#### Florists, photographers, and caterers

| Goal | How this Actor helps |
|---|---|
| Prioritize by wedding date | Sort enriched leads by public wedding date |
| Route by geography | Filter on public city and state |

#### Registry and gifting services

| Goal | How this Actor helps |
|---|---|
| Resolve a couple to their registry | Get the public registry URL and website link |
| Verify a couple exists on Zola | Check the has-registry and has-website flags |

#### CRM and operations teams

| Goal | How this Actor helps |
|---|---|
| Fill gaps on known records | Add wedding date, venue, and location to a name you already hold |
| Keep data clean | Ingest structured CSV or JSON instead of manual entry |

### 🔌 Automating Zola Wedding Website Scraper

Run this Actor on a schedule and pipe results anywhere with Apify integrations:

- **Make** and **Zapier** for no-code workflows
- **Slack** notifications when a run finishes
- **Airbyte** to load results into a warehouse
- **GitHub** Actions to trigger runs
- **Google Drive** to archive exports

### 🌟 Beyond business use cases

- **Research:** study public wedding trends such as popular dates, venues, and regions.
- **Personal:** find a friend's public wedding website or registry link from their name.
- **Non-profit:** understand event-planning patterns for community programs.
- **Experimentation:** a clean, real-world dataset for data and ML practice.

### 🤖 Ask an AI assistant

Paste your exported data into any assistant and ask away:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

Example prompts: "Group these couples by state" or "List venues with weddings after June 2026".

### ❓ Frequently Asked Questions

**1. What does this Actor actually do?**
It enriches a name into public wedding-website details. You give it a name, it looks that name up in Zola's public couple directory and returns the public facts.

**2. Is this a way to discover or buy a list of couples?**
There is an optional discover mode that browses Zola's public wedding directory and can filter by US state and wedding date, so you can use it without a name in hand. It still reads only publicly published wedding pages and skips private, passcode-protected sites. It does not sell or provide contact data. Search mode remains the default and simply enriches names you already provide.

**3. Does it collect private or contact data?**
No. It collects only what a couple has chosen to publish publicly on their Zola wedding website. It does not collect emails, phone numbers, guest lists, or RSVPs, and it skips passcode-protected private sites.

**4. Do I need a Zola login?**
No. Only publicly available pages are read. There are no logins or paywalls.

**5. How many couples can one name return?**
Up to 50 public matches per name. Use a first + last name to narrow a common surname.

**6. Which fields are always present?**
The slug, website and registry URLs, both partners' names, and the has-website and has-registry flags are consistently present. Location and venue appear when the couple published them.

**7. Why are some venue or location fields empty?**
Because that couple did not publish them. The Actor never guesses; empty means not public.

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

**9. Does it use a proxy or a browser?**
No. It runs on plain HTTP, which keeps runs fast and inexpensive.

**10. How current is the data?**
Every record includes a `scrapedAt` timestamp and reflects the public page at run time.

**11. Can I enrich many names at once?**
Yes. Pass an array of names under `searchTerms` and the Actor processes each in turn.

**12. Is this Actor affiliated with Zola?**
No. It is an independent tool that reads publicly available data.

### 🔌 Integrate with any app

Every run produces a dataset you can pull via the Apify API, webhooks, or the built-in integrations above, so results flow straight into your CRM, sheet, or warehouse.

### 🔗 Recommended Actors

- **Google Maps Scraper** for venue and vendor business details.
- **Instagram Profile Scraper** for public vendor social profiles.
- **Website Content Crawler** for general public-site extraction.
- **Contact Details Scraper** for public business contact info.

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

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

> **⚠️ Disclaimer:** This is an independent enrichment tool and is not affiliated with, endorsed by, or sponsored by Zola. It collects only publicly available data that couples have chosen to publish on their public wedding websites, and it skips private, passcode-protected sites. It does not provide contact details or private information. Use the data responsibly and in compliance with applicable laws (including privacy and data-protection rules) and Zola's terms.

# Actor input Schema

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

How to collect couples. 'Search by name' enriches names you already have. 'Discover from directory' pulls public couples straight from Zola's own wedding sitemaps, no name needed.

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

Used in Search mode only. One or more names to look up on Zola's public couple directory. Use a surname (for example smith) or either partner's first + last name (for example jack jill). Each term returns up to 50 matching couples.

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

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

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

When enabled, each couple with a public wedding website is opened to pull location (city/state), venue, event date, split partner names and headline. Discover mode always enriches. Disable to speed up Search mode (names and links only).

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

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

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

Discover mode only. Keep only couples in this US state. Accepts a full name (California) or a 2-letter code (CA). Matched against the couple's location and venue. Leave empty for all states.

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

Discover mode only. Keep only couples whose wedding date is on or after this date (ISO, for example 2026-01-01). Leave empty for no lower bound.

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

Discover mode only. Keep only couples whose wedding date is on or before this date (ISO, for example 2026-12-31). Leave empty for no upper bound.

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

Discover mode only. Maximum number of couples to fetch and examine while looking for matches. Prevents a narrow filter from walking forever. Default 2000.

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

Discover mode only. When on (default), each run starts at a random sitemap and offset, so repeated runs return different couples and cover the whole directory over time. Turn off (or set Start Sitemap/Offset) for reproducible runs.

## `startSitemap` (type: `integer`):

Discover mode only. Optional. Begin at this wedding sitemap number (1 to 17) instead of a random one. Overrides Randomize for the sitemap choice.

## `startOffset` (type: `integer`):

Discover mode only. Optional. Begin at this index within the start sitemap (each sitemap lists up to 50,000 couples). Overrides Randomize for the offset.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "smith"
  ],
  "maxItems": 10,
  "enrichDetails": true,
  "onlyComplete": false,
  "maxScan": 2000,
  "randomizeStart": true
}
```

# 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"
    ],
    "maxItems": 10,
    "maxScan": 2000
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/zola-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"],
    "maxItems": 10,
    "maxScan": 2000,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zola Wedding Couple and Venue Scraper",
        "description": "Search Zola by a couple's names and pull their public wedding website. Every record returns both partners first and last names, the wedding date, city and state, the venue name and address, and links to the couple website and registry. Great for enriching wedding leads.",
        "version": "0.1",
        "x-build-id": "2O5Saefltr5Qic0GY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~zola-couples-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-zola-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~zola-couples-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-zola-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~zola-couples-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-zola-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 names you already have. 'Discover from directory' pulls public couples straight from Zola's own wedding sitemaps, no name needed.",
                        "default": "search"
                    },
                    "searchTerms": {
                        "title": "Search Terms (couple names)",
                        "type": "array",
                        "description": "Used in Search mode only. One or more names to look up on Zola's public couple directory. Use a surname (for example smith) or either partner's first + last name (for example jack jill). Each term returns up to 50 matching couples.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "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"
                    },
                    "enrichDetails": {
                        "title": "Enrich with wedding-website details",
                        "type": "boolean",
                        "description": "When enabled, each couple with a public wedding website is opened to pull location (city/state), venue, event date, split partner names and headline. Discover mode always enriches. Disable to speed up Search mode (names and links only).",
                        "default": true
                    },
                    "onlyComplete": {
                        "title": "Only complete leads",
                        "type": "boolean",
                        "description": "When enabled, keeps only couples that have both partner names, a wedding date, and a city. Skips sparse records instead of returning them with blank fields. Skipped couples are counted in the log, not silently dropped.",
                        "default": false
                    },
                    "usState": {
                        "title": "US State",
                        "type": "string",
                        "description": "Discover mode only. Keep only couples in this US state. Accepts a full name (California) or a 2-letter code (CA). Matched against the couple's location and venue. Leave empty for all states."
                    },
                    "weddingDateFrom": {
                        "title": "Wedding Date From",
                        "type": "string",
                        "description": "Discover mode only. Keep only couples whose wedding date is on or after this date (ISO, for example 2026-01-01). Leave empty for no lower bound."
                    },
                    "weddingDateTo": {
                        "title": "Wedding Date To",
                        "type": "string",
                        "description": "Discover mode only. Keep only couples whose wedding date is on or before this date (ISO, for example 2026-12-31). Leave empty for no upper bound."
                    },
                    "maxScan": {
                        "title": "Max Scan (Discover budget)",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Discover mode only. Maximum number of couples to fetch and examine while looking for matches. Prevents a narrow filter from walking forever. Default 2000."
                    },
                    "randomizeStart": {
                        "title": "Randomize start position",
                        "type": "boolean",
                        "description": "Discover mode only. When on (default), each run starts at a random sitemap and offset, so repeated runs return different couples and cover the whole directory over time. Turn off (or set Start Sitemap/Offset) for reproducible runs.",
                        "default": true
                    },
                    "startSitemap": {
                        "title": "Start Sitemap (1-17)",
                        "minimum": 1,
                        "maximum": 17,
                        "type": "integer",
                        "description": "Discover mode only. Optional. Begin at this wedding sitemap number (1 to 17) instead of a random one. Overrides Randomize for the sitemap choice."
                    },
                    "startOffset": {
                        "title": "Start Offset",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Discover mode only. Optional. Begin at this index within the start sitemap (each sitemap lists up to 50,000 couples). Overrides Randomize for the offset."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
