# The Knot Scraper (Cheap) (`data_api/the-knot-scraper-cheap`) Actor

The Knot Marketplace Scraper pulls vendor names, ratings, prices, and contact details from TheKnot.com listing pages, so you get a clean dataset for outreach or market research instead of clicking through pages.

- **URL**: https://apify.com/data\_api/the-knot-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (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 $3.99 / 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

## The Knot Wedding Vendor Scraper

![The Knot Wedding Vendor Scraper](cover.jpg)

The Knot lists thousands of wedding vendors across every category and city, but the site gives you no way to pull that into a spreadsheet. If you are building a vendor directory, mapping a local market, or sizing up the competition, copying names and ratings card by card gets old fast. This scraper does it for you: hand it a marketplace URL, or just a category and city, and every vendor comes back as one tidy row with the business name, service area, rating, review count, price tier, portfolio photos, and award badges already split into fields.

### What you get

Each vendor card turns into a single row with a steady shape, so your columns line up when you drop the results into a sheet or database. The fields break down into three groups:

- **Business** — `businessName`, `profileUrl`, `serviceArea`, `vendorCategory`, `priceTier`, `bioSnippet`
- **Reputation** — `starRating`, `reviewsTotal`, `bestOfWeddings`, `awardList`, `badgeLabels`
- **Media and source** — `photoLinks`, `sourcePageUrl`, `sourcePageNumber`, `listingId`, `collectedAt`

### Quick start

1. Press **Try for free** to open the input form.
2. Paste one or more The Knot marketplace URLs into **Marketplace listing URLs**. No URL handy? Fill in **Vendor category slug** and **City and state slug** instead and the actor builds the URL for you.
3. Set **Pages to read per URL** and **Total vendors to keep** to size the run.
4. Hit **Start**, then export your results as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

### Use cases

- **Vendor directory building** — assemble a clean list of photographers, florists, or DJs for a city you cover
- **Local market research** — compare ratings, review volume, and price tiers across an area
- **Lead lists for wedding services** — find active vendors by category and location for outreach
- **Competitor tracking** — watch where rival businesses rank and which awards they carry
- **Planning tools and apps** — feed structured vendor data into your own site, sheet, or product

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `listingUrls` | array of strings | One of `listingUrls` or `categorySlug` + `locationSlug` | The Knot marketplace result URLs to harvest. Each runs with pagination. |
| `categorySlug` | string | Optional | Service slug used to build a search URL when no listing URLs are given, e.g. `wedding-florists`. |
| `locationSlug` | string | Optional | City-and-state slug paired with the category to build a search URL, e.g. `austin-tx`. |
| `pageLimit` | integer | No | Result pages to walk per URL; each page holds up to 30 vendors. Default `2`. |
| `resultsLimit` | integer | No | Cap on total vendor rows kept across all URLs. Default `40`. |
| `timeoutSeconds` | integer | No | Seconds to wait per page before giving up. Default `75`. |

#### Example input

```json
{
    "listingUrls": [
        "https://www.theknot.com/marketplace/wedding-florists-austin-tx"
    ],
    "categorySlug": "wedding-florists",
    "locationSlug": "austin-tx",
    "pageLimit": 2,
    "resultsLimit": 40,
    "timeoutSeconds": 75
}
````

### Output

Every vendor card on the results pages becomes one row, paginated up to your limit. Fields The Knot does not show for a given vendor come back empty rather than guessed.

#### Example output

```json
{
    "listingId": "a1b2c3d4-5678-90ab-cdef-1234567890ab",
    "businessName": "Bloom & Branch Floral Co.",
    "profileUrl": "https://www.theknot.com/marketplace/bloom-and-branch-floral-co-austin-tx-2012345",
    "serviceArea": "Austin, TX",
    "starRating": 4.9,
    "reviewsTotal": 138,
    "priceTier": "$$ – Affordable",
    "bioSnippet": "Austin-based studio crafting seasonal arrangements for intimate ceremonies and large receptions across the Hill Country.",
    "photoLinks": [
        "https://media-api.xogrp.com/images/example-1~rs_768.h",
        "https://media-api.xogrp.com/images/example-2~rs_768.h"
    ],
    "awardList": [
        "Award winner (3x)"
    ],
    "bestOfWeddings": true,
    "badgeLabels": [
        "Responds quickly"
    ],
    "vendorCategory": "Wedding Florists",
    "sourcePageUrl": "https://www.theknot.com/marketplace/wedding-florists-austin-tx",
    "sourcePageNumber": 1,
    "collectedAt": "2026-06-30T12:00:00.000000+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | Unique identifier The Knot assigns to the vendor listing |
| `businessName` | string | Trading name of the wedding vendor |
| `profileUrl` | string | Direct link to the vendor's profile on The Knot |
| `serviceArea` | string | City and state the vendor serves |
| `starRating` | number | Mean couple review score on a five-star scale |
| `reviewsTotal` | integer | Number of couple reviews on the listing |
| `priceTier` | string | Price band the vendor advertises, such as $$ or $$$ |
| `bioSnippet` | string | Short marketing excerpt from the vendor card |
| `photoLinks` | array | Links to portfolio photos featured on the card |
| `awardList` | array | Award labels shown on the listing |
| `bestOfWeddings` | boolean | True when the vendor holds a Best of Weddings award |
| `badgeLabels` | array | Extra badges on the card, e.g. responds quickly |
| `vendorCategory` | string | Service category inferred from the listing |
| `sourcePageUrl` | string | The results page this record was read from |
| `sourcePageNumber` | integer | Which pagination page the vendor appeared on |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |

### Tips for best results

- **Filter on The Knot first.** Open the marketplace, choose your category and city, then copy that URL — a focused search gives you a cleaner, more relevant dataset.
- **No URL? Use the slugs.** Leave `listingUrls` empty and set `categorySlug` plus `locationSlug`, and the actor assembles the search URL for you.
- **Keep test runs small.** Start with `resultsLimit` at 20–40 to confirm the output fits your pipeline, then raise it for the full pull.
- **Reach deeper with `pageLimit`.** One page returns up to 30 vendors; bump the limit to walk further into the results.
- **Raise `timeoutSeconds`** if pages time out, since rendered marketplace pages can be slow to load.

### How can I use The Knot wedding vendor data?

**How can I use The Knot Wedding Vendor Scraper to build a vendor directory?**
Paste the marketplace URL for a category and city, set `resultsLimit` to the volume you want, and export to CSV or Excel. Each row carries `businessName`, `profileUrl`, `serviceArea`, and `priceTier`, so you get a ready-made directory of active vendors without copying cards by hand.

**How can I compare wedding vendors by rating and reviews?**
Pull a full category for one area and sort the rows by `starRating` and `reviewsTotal`. With `bestOfWeddings` and `awardList` alongside, you can quickly see which photographers, florists, or DJs are the most trusted in town.

**How can I scrape The Knot by category and location without a URL?**
Skip `listingUrls` and fill in `categorySlug` (such as `wedding-djs`) and `locationSlug` (such as `miami-fl`). The actor builds the marketplace search URL, walks the pages, and returns one structured row per vendor — handy for collecting leads across several markets.

**How can I gather wedding vendor leads for outreach?**
Run the scraper across the categories and cities you serve, then use `businessName`, `profileUrl`, and `serviceArea` to shape a contact list. The `badgeLabels` field even flags vendors that respond quickly, so you can prioritize the most responsive ones.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `listingUrls` (type: `array`):

Paste one or more The Knot marketplace result URLs to harvest. For example https://www.theknot.com/marketplace/wedding-florists-austin-tx.

## `categorySlug` (type: `string`):

Service slug used to assemble a search URL when no listing URLs are given. Try wedding-florists, wedding-djs, wedding-cakes, or wedding-photo-booth-rentals.

## `locationSlug` (type: `string`):

City-and-state slug that joins the category slug to form a search URL. Try austin-tx, miami-fl, or seattle-wa.

## `pageLimit` (type: `integer`):

Number of result pages to walk through for each listing URL. A single page holds up to 30 vendors.

## `resultsLimit` (type: `integer`):

Hard cap on the number of vendor rows gathered across every URL in one run.

## `timeoutSeconds` (type: `integer`):

How long to wait on each page before giving up. Rendered pages are slow, so allow at least 60 seconds.

## Actor input object example

```json
{
  "listingUrls": [
    "https://www.theknot.com/marketplace/wedding-florists-austin-tx"
  ],
  "categorySlug": "wedding-florists",
  "locationSlug": "austin-tx",
  "pageLimit": 1,
  "resultsLimit": 30,
  "timeoutSeconds": 75
}
```

# 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 = {
    "listingUrls": [
        "https://www.theknot.com/marketplace/wedding-photographers-new-york-ny"
    ],
    "categorySlug": "wedding-photographers",
    "locationSlug": "austin-tx"
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/the-knot-scraper-cheap").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 = {
    "listingUrls": ["https://www.theknot.com/marketplace/wedding-photographers-new-york-ny"],
    "categorySlug": "wedding-photographers",
    "locationSlug": "austin-tx",
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/the-knot-scraper-cheap").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 '{
  "listingUrls": [
    "https://www.theknot.com/marketplace/wedding-photographers-new-york-ny"
  ],
  "categorySlug": "wedding-photographers",
  "locationSlug": "austin-tx"
}' |
apify call data_api/the-knot-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Knot Scraper (Cheap)",
        "description": "The Knot Marketplace Scraper pulls vendor names, ratings, prices, and contact details from TheKnot.com listing pages, so you get a clean dataset for outreach or market research instead of clicking through pages.",
        "version": "0.0",
        "x-build-id": "n5i49EZoe5NW1JE6u"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~the-knot-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-the-knot-scraper-cheap",
                "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/data_api~the-knot-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-the-knot-scraper-cheap",
                "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/data_api~the-knot-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-the-knot-scraper-cheap",
                "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": {
                    "listingUrls": {
                        "title": "Marketplace listing URLs",
                        "type": "array",
                        "description": "Paste one or more The Knot marketplace result URLs to harvest. For example https://www.theknot.com/marketplace/wedding-florists-austin-tx.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categorySlug": {
                        "title": "Vendor category slug",
                        "type": "string",
                        "description": "Service slug used to assemble a search URL when no listing URLs are given. Try wedding-florists, wedding-djs, wedding-cakes, or wedding-photo-booth-rentals."
                    },
                    "locationSlug": {
                        "title": "City and state slug",
                        "type": "string",
                        "description": "City-and-state slug that joins the category slug to form a search URL. Try austin-tx, miami-fl, or seattle-wa."
                    },
                    "pageLimit": {
                        "title": "Pages to read per URL",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of result pages to walk through for each listing URL. A single page holds up to 30 vendors.",
                        "default": 1
                    },
                    "resultsLimit": {
                        "title": "Total vendors to keep",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of vendor rows gathered across every URL in one run.",
                        "default": 30
                    },
                    "timeoutSeconds": {
                        "title": "Per-page timeout (seconds)",
                        "minimum": 15,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on each page before giving up. Rendered pages are slow, so allow at least 60 seconds.",
                        "default": 75
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
