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

Scrapes WeddingWire couple profiles by name search or sequential ID discovery. Returns partner names, wedding date, location, and website details as flat rows.

- **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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### WeddingWire Couple Scraper

**Scrape WeddingWire couple profiles by name search or by walking public website IDs, up to a million per run.** Each record returns partner names, wedding date, location, and website details. No login or API key. Export to CSV, JSON, Excel, or XML.

WeddingWire's couple directory holds millions of public wedding websites, but there is no official API to collect them in bulk. This Actor reads the public directory directly, either by searching for specific names you provide or by walking sequential website IDs to discover couples without any name. It returns each matched couple in one fixed schema, ready for lead lists, market analysis, or invitation campaigns.

| Who uses it | What they scrape WeddingWire for |
|---|---|
| Wedding vendors | Build a targeted list of engaged couples in their service area for direct outreach. |
| Market researchers | Analyze wedding date trends, geographic distribution, and couple naming patterns across the US. |
| Event planners | Discover new couples planning weddings in a specific state or date range to pitch services. |
| Lead generation agencies | Compile fresh, verified couple leads with wedding dates and locations for resale or CRM enrichment. |

### What it does

This Actor collects WeddingWire couple profiles by name search or sequential ID discovery, and returns each couple as a flat row with partner names, wedding date, location, and website details.

- 🔍 **Search by name:** Provide one or more partner names (first, last, or full) and get back up to 20 public couples per term from the WeddingWire directory.
- 🚶 **Discover by ID walk:** Walk WeddingWire's sequential public website IDs to collect couples without any name, starting from a specific ID or a random fresh point.
- 🎲 **Randomized discovery:** When discover mode runs without a fixed start ID, it picks a random point in the 42M-46M band each run so repeated runs return different couples.
- 🗺️ **US state filter:** In discover mode, keep only couples whose public location matches a given state (full name or 2-letter code), skipping those with no location.
- 📅 **Wedding date range:** In discover mode, filter couples to only those with a wedding date falling within a specified ISO date window.
- ✅ **Complete leads only:** Optionally skip sparse records and keep only couples that have both a partner name and a wedding date, with skipped counts logged.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with WeddingWire data

**📋 Build a local lead list.**

A wedding photographer in Texas runs discover mode with the state filter set to 'TX' and a date range for the next 12 months, collecting hundreds of qualified couple leads with wedding dates and locations.

**🔎 Enrich a CRM list.**

A bridal shop uploads a list of customer names into search mode, and the Actor returns each matching WeddingWire profile with the couple's wedding date, location, and website welcome message.

**📊 Analyze wedding seasonality.**

A market researcher runs discover mode across multiple states without a date filter, then aggregates wedding dates by month to identify peak booking seasons for a national campaign.

**🔄 Refresh leads on a schedule.**

A lead generation agency schedules the Actor weekly with randomized start IDs, pulling fresh couple profiles each run to keep their CRM current with newly engaged couples.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key needed** | Reads WeddingWire's public couple directory directly, no registration or OAuth required. |
| **Two collection modes** | Search by specific names to enrich a known list, or walk IDs to discover couples you did not know existed. |
| **Built-in filters** | Narrow discover runs by US state, wedding date range, and record completeness before data lands in your dataset. |
| **Scalable volume** | Collect up to a million couples per run with a configurable scan budget and item cap. |

### How it compares

This Actor focuses exclusively on WeddingWire couple profiles, while the competitors below scrape vendor listings across one or more wedding platforms.

| Feature | ParseForge | Wedding Vendor Scraper - 7 Sites | WeddingWire Vendor Directory Scraper | Wedding Vendor Scraper - Bridebook, The Knot, WeddingWire, Zola |
|---|---|---|---|---|
| Scrapes WeddingWire couple profiles | Yes | Not listed | Not listed | Not listed |
| Scrapes WeddingWire vendor listings | No | Yes | Yes | Yes |
| Discovery by website ID walk | Yes | Not listed | Not listed | Not listed |
| Search couples by name | Yes | Not listed | Not listed | Not listed |
| Multi-site vendor scraping | No | Yes (7 sites) | Not listed | Yes (4 sites) |
| Wedding date range filter | Yes | Not listed | Not listed | Not listed |

### Configure the run

Drive the Actor from couple names or sequential website IDs, and apply state, date range, and completeness filters as each profile is read so only matching couples reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "searchTerms": [
 "Smith"
 ],
 "maxScan": 3000,
 "maxItems": 10
}
```

A larger pull:

```json
{
 "searchTerms": [
 "Smith"
 ],
 "maxScan": 3000,
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.005 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.50 |
| 1,000 results | $5.00 |
| 10,000 results | $50.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [WeddingWire Couple Scraper](https://apify.com/parseforge/weddingwire-couples-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to WeddingWire through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/weddingwire-couples-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results in discover mode?**

Check your filters. A narrow state filter combined with a tight date range can mean many IDs are walked before a match is found. Try widening the date range, removing the state filter, or increasing the max scan budget. Also confirm your start website ID is in a valid range.

**Why does search mode return fewer couples than I expected?**

WeddingWire's public directory shows up to 20 couples per search term. If your search term is very common, you may hit that cap. Try more specific names, or switch to discover mode for broader collection.

**The run stopped before reaching my max items setting.**

In discover mode, the run stops when either max items or max scan budget is reached. If you hit the scan budget first, increase the max IDs to scan value. In search mode, the run stops when all search terms have been exhausted.

**Some couple records are missing location or wedding date.**

Not every WeddingWire couple fills in their full profile publicly. Enable 'Only complete leads' to skip sparse records, or leave it off to collect everything and filter later in your own tools.

**I am getting duplicate couples across runs.**

In discover mode without a fixed start ID, enable randomized start to vary the starting point each run. For search mode, deduplicate by the couple's website URL in your downstream processing.

### FAQ

| Question | Answer |
|---|---|
| Does this Actor scrape WeddingWire vendors or couples? | This Actor scrapes only WeddingWire couple profiles and their public wedding websites. For vendor data, see the WeddingWire Vendor Directory Scraper or the multi-site vendor scrapers on Apify Store. |
| What information does each couple record include? | Each record returns partner names, wedding date, location (city and state when available), the couple's WeddingWire website URL, and their welcome message when details fetching is enabled. |
| How does discover mode find couples without a name? | WeddingWire assigns sequential numeric IDs to couple websites. Discover mode walks those IDs downward from a starting point, reading each public profile and applying your filters, so it finds couples you would not know to search for by name. |
| Can I filter couples by location? | Yes, in discover mode you can set a US state filter using the full state name or the two-letter postal code. Couples without a public location are skipped when this filter is active. |
| What is the randomized start option? | When discover mode runs without a fixed start website ID, randomized start picks a random point in the 42,000,000 to 46,000,000 ID band, which covers the freshest upcoming weddings. This means repeated runs return different couples instead of the same set. |
| How many couples can I collect in one run? | You set the maximum couples per run, up to one million. In discover mode you also set a scan budget (max IDs to walk), and the run stops when either limit is reached. |
| Does search mode return all matching couples for a name? | Search mode returns up to 20 public couples per search term, which is WeddingWire's directory display limit. For broader discovery without name constraints, use discover mode. |
| What happens when I enable 'Only complete leads'? | The Actor keeps only couples that have both a partner name and a wedding date. Sparse records are skipped and counted in the log, so you know how many were filtered out. |
| Is a WeddingWire login required? | No. This Actor reads only the public-facing couple directory and wedding websites, so no account, login, or API key is needed. |
| Can I export the data to Google Sheets? | Yes. You can export your dataset to CSV, JSON, Excel, or XML from Apify, and integrations can push the data directly to Google Sheets, Airtable, or your CRM. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by WeddingWire, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# 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`):

Maximum number of couples to collect per run.

## `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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/weddingwire-couples-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/lRxMSRf1fKl9btmz3/builds/yUPj2Lkdg0J3qjdrr/openapi.json