# Klaviyo Campaign Drafter (`luis.pinto/klaviyo-campaign-drafter`) Actor

Turn product URLs into draft Klaviyo email campaigns. Scrapes each product, writes copy with Claude, creates a draft campaign per product via the Klaviyo MCP Connector. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/luis.pinto/klaviyo-campaign-drafter.md
- **Developed by:** [Luis Pinto](https://apify.com/luis.pinto) (community)
- **Categories:** E-commerce, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.70 / 1,000 emails

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

## Klaviyo Campaign Drafter

Turn a list of product URLs into ready-to-review Klaviyo email campaign drafts — for DTC operators and e-commerce marketers who want to stop hand-writing product-launch emails.

### What does Klaviyo Campaign Drafter do?

Klaviyo Campaign Drafter turns 1–20 product URLs into draft email campaigns inside your own Klaviyo account. It scrapes each product, writes the email copy with Claude, and creates one draft campaign per product through the **Klaviyo MCP Connector** — so the Actor never sees your API key.

- 🛒 Scrapes any e-commerce product URL via apify/e-commerce-scraping-tool
- 🧠 Writes subject + preview text + headline + body with Claude (Sonnet 4.6 by default)
- 🔌 Pushes drafts through Klaviyo's official `mcp.klaviyo.com` connector
- 📝 Every campaign is created as a **draft** — Klaviyo never sends without your click
- 🔗 Returns a deep link straight to the first new draft in your Klaviyo dashboard

Result: a sub-3-minute path from a list of product URLs to reviewable email campaigns ready to schedule in Klaviyo.

### What gets created in your Klaviyo account?

For each product URL, two linked resources: a **draft email template** (HTML with product image, headline, body, "Shop now" CTA) and a **draft campaign** (subject ≤50 chars, preview ≤110 chars, assigned to your chosen list and verified sender). Everything is a draft — refine, schedule, and send from Klaviyo when ready.

### Can I use Klaviyo Campaign Drafter with Shopify, BigCommerce, WooCommerce, Amazon, Etsy?

Yes. Klaviyo Campaign Drafter works with any canonical product URL that Apify's E-Commerce Scraping Tool can read — Shopify, BigCommerce, WooCommerce, Magento, Amazon, Walmart, eBay, Etsy, Allbirds, Zalando, Target, AliExpress, and most direct-to-consumer sites. Mix domains in a single run; each URL becomes one draft campaign.

Skip category, search-results, and collection pages — those return noisy data and degrade email copy quality.

### How does Klaviyo Campaign Drafter work?

The Process:

1. **Scrape products** — single batched call to apify/e-commerce-scraping-tool.
2. **Read brand voice** *(optional)* — fetches the brand's About page for tone.
3. **Sample recent campaigns** — reads up to 10 of your recent Klaviyo campaigns via MCP for style examples.
4. **Generate email copy** — Claude writes subject + preview text + headline + body per product.
5. **Create in Klaviyo** — one draft email template + one draft campaign per product via MCP.
6. **Return deep link** — writes the Klaviyo dashboard URL to the default key-value store.

It's like having a junior copywriter draft 20 product-launch emails while you grab coffee — except every draft uses your real products and real brand voice.

### Why use Klaviyo Campaign Drafter vs writing emails manually or using generic AI tools?

| Feature | Manual in Klaviyo | Generic AI copywriting tools | Klaviyo Campaign Drafter |
|---|---|---|---|
| Time per email | 20–40 minutes | 5–10 minutes | ~15 seconds |
| Uses your real product data | By hand | Often generic | Scraped live |
| Drafts in YOUR Klaviyo account | Yes | No (output is text only) | Yes — ready to review |
| Brand voice from existing campaigns | Manual | No | Yes — samples recent campaigns |
| Token handling | N/A | You paste an API key | OAuth via Apify MCP |
| Cost per 20 emails | Hours of work | $20–$100/mo subscription | Cents per run |

### How to use Klaviyo Campaign Drafter?

1. **Create an Apify account** at [apify.com](https://apify.com).
2. **Connect Klaviyo** — Apify Console → Settings → MCP Connectors → Add new connector → paste `https://mcp.klaviyo.com/mcp` → Authorize. One click, no developer app registration needed.
3. **Open Klaviyo Campaign Drafter** and paste 1–20 product URLs.
4. **Pick your Klaviyo connector** from the dropdown.
5. **Enter your Klaviyo list ID** (Klaviyo > Audience > Lists & segments > pick a list > copy the 6-character ID from the URL).
6. **Enter your verified sender email** (Klaviyo > Settings > Domains & sending).
7. **Click Start.** When the run finishes, open the deep link in the key-value store output.

Tip: start with 2–3 URLs the first time so you can sanity-check the generated copy before scaling to 20.

### How much does Klaviyo Campaign Drafter cost?

Apify pay-per-event billing. Typical 10-product run:

- Product scraping: ~$0.02 per URL
- LLM tokens: ~$0.02–$0.08 per email on Claude Sonnet 4.6
- Klaviyo Marketing API calls: **free** (Klaviyo doesn't charge for API access)

Expect $0.40–$1.00 per run of 10 products on defaults. Claude Opus 4.7 raises LLM cost ~10×.

### ⬇️ Input

| Field | Required | Description |
|---|---|---|
| `productUrls` | yes | 1–20 product page URLs |
| `klaviyoConnector` | yes | Connected Klaviyo MCP Connector |
| `klaviyoListId` | yes | Klaviyo list or segment ID (6 chars) |
| `fromEmail` | yes | Verified sender email |
| `fromName` | no | Sender name (default: "New Arrivals") |
| `campaignNamePrefix` | no | Defaults to `Apify MCP Draft – <date>` |
| `includeAboutPage` | no | Brand voice from About page, default `false` |
| `model` | no | `anthropic/claude-sonnet-4.6` or `anthropic/claude-opus-4.7` |

### ⬆️ Output

**Dataset** — one row per input URL with a stable shape:

```json
{
  "productUrl": "https://www.allbirds.com/products/mens-wool-runners",
  "productTitle": "Men's Wool Runners",
  "productImage": "https://cdn.shopify.com/.../wool-runner.jpg",
  "subject": "Soft step. Naturally cooler.",
  "previewText": "Merino wool that breathes — meet the all-day sneaker.",
  "headline": "Comfort, woven in.",
  "body": "Allbirds Wool Runners are made with...",
  "klaviyo_template_id": "VRkP4n",
  "klaviyo_campaign_id": "01JABCDEFGHIJKLMNOPQRSTUVW",
  "status": "draft",
  "error": false
}
````

**Key-value store** — single key `KLAVIYO_CAMPAIGN_DEEPLINK`:

```json
{
  "url": "https://www.klaviyo.com/campaign/01JABCDEFGHIJKLMNOPQRSTUVW/edit",
  "campaignIds": ["01JABCDEFGHIJKLMNOPQRSTUVW", "01JBCDEFGHIJKLMNOPQRSTUVWX"],
  "createdAt": "2026-05-19T14:30:00.000Z"
}
```

### How to run Klaviyo Campaign Drafter via the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/luis.pinto~klaviyo-campaign-drafter/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productUrls": ["https://www.allbirds.com/products/mens-wool-runners"],
    "klaviyoConnector": "YOUR_CONNECTOR_ID",
    "klaviyoListId": "Yh5K8m",
    "fromEmail": "hello@yourbrand.com",
    "fromName": "Allbirds"
  }'
```

Schedule weekly drafts for new arrivals by pointing an Apify Schedule at this Actor with your latest product URLs.

### Can I use Klaviyo Campaign Drafter with MCP?

Yes — this Actor **is** an MCP showcase. It calls Klaviyo's official `mcp.klaviyo.com/mcp` server through Apify's new MCP Connectors feature. Connect once in Apify Settings → MCP Connectors → paste the Klaviyo URL → authorize; the Actor never sees your token.

Klaviyo Campaign Drafter is also itself callable from MCP-aware AI agents that can run Apify Actors (Claude, ChatGPT, n8n, Make, Zapier, LangChain).

### Are there other tools in Apify Store?

- 🛒 [apify/e-commerce-scraping-tool](https://apify.com/apify/e-commerce-scraping-tool) — the upstream scraper Klaviyo Campaign Drafter depends on
- ✏️ [apify/ecommerce-product-description-rewriter](https://apify.com/apify/ecommerce-product-description-rewriter) — rewrite product descriptions for SEO
- 📊 [apify/web-scraper](https://apify.com/apify/web-scraper) — extract structured data from any website to feed into your Klaviyo segments

### Limitations

- One product per draft campaign — no multi-product digests in v1
- English copy only
- Requires a connected Klaviyo MCP Connector in Apify Settings (one-time setup)
- Sender email must be already verified in Klaviyo before drafts become sendable
- Email template uses a minimal built-in HTML layout — for advanced layouts, copy the template in Klaviyo's drag-and-drop editor after the draft lands

### FAQ

**1. Is using Klaviyo Campaign Drafter legal?**
Yes. The Actor uses Klaviyo's official MCP server with your OAuth consent and scrapes only publicly accessible product pages. You're responsible for the content of the emails you eventually send.

**2. Why does it create drafts instead of sending?**
Safety. Klaviyo never sends a campaign without your Send click. Drafts let you review copy, audience, and timing first.

**3. Do I need a Klaviyo paid plan?**
No. Works on free and paid plans alike. Klaviyo's own list-size and send limits apply.

**4. Do I need to verify the sender email first?**
Yes — Klaviyo requires every sender to be verified before drafts become sendable.

**5. What if scraping fails on one of my URLs?**
The run continues. That URL becomes a soft-fail row (`error: true`, `errorType`, `reason`, `fix`); the rest succeed. Common causes: category URLs, login-gated pages, sites without structured product data.

**6. What languages does it support?**
English only, by design.

**7. Can it create flows, segments, or signup forms?**
No — campaigns only. Flows and segments are out of scope for the POC.

**8. How do I refine the audience after the run?**
Open the deep link — each draft is in your Klaviyo Campaigns list, ready to edit audience, A/B test, or schedule.

**9. Do I need to register my own Klaviyo developer app?**
No. Klaviyo's MCP supports **dynamic OAuth client registration** — Apify registers itself when you click Authorize. One click.

**10. Can I use it with the Apify API and integrations?**
Yes — regular Apify Actor. Run via API (curl example above), schedule, or call from Zapier, Make, n8n, LangChain, MCP clients, Google Sheets.

### Your feedback

Found a bug or want a feature? Open an issue from the Actor's Issues tab — Luís reads every one.

# Actor input Schema

## `productUrls` (type: `array`):

Between 1 and 20 product page URLs. Each URL becomes one Klaviyo draft campaign — the Actor scrapes the title, description, price, and main image, then Claude writes a subject + preview text + email body. Use canonical product pages (NOT category, collection, or search-result pages), otherwise the scraper extracts noisy data. Mixing domains is fine (Shopify, BigCommerce, WooCommerce, Amazon, Walmart, etc.). Example: https://allbirds.com/products/mens-wool-runners. Tip: 5–10 products per run is a good batch size for review in the Klaviyo dashboard.

## `klaviyoConnector` (type: `string`):

Your connected Klaviyo MCP Connector. BEFORE running this Actor, create one in Apify Console > Settings > MCP Connectors > Add new connector > paste https://mcp.klaviyo.com/mcp > Authorize. Klaviyo's MCP supports dynamic OAuth client registration so you don't need to register your own Klaviyo developer app — one click and you're connected.

## `klaviyoListId` (type: `string`):

The Klaviyo list or segment ID the draft campaigns will be addressed to. Find it in Klaviyo > Audience > Lists & segments > pick a list > copy the 6-character ID from the URL (looks like Yh5K8m). The campaigns are still drafts — they won't send until you click Send in the Klaviyo dashboard.

## `fromEmail` (type: `string`):

Sender email address for the draft campaigns. MUST already be verified as a sending identity in your Klaviyo account (Klaviyo > Settings > Domains & sending) — otherwise the campaign can be created as a draft but won't be sendable. Example: hello@yourbrand.com.

## `fromName` (type: `string`):

The sender name recipients see in their inbox. Defaults to 'New Arrivals'. Keep it short — most inboxes truncate after ~25 characters. Examples: 'Allbirds', 'Casper Team', 'Sarah from Glossier'.

## `campaignNamePrefix` (type: `string`):

Prefix shown in the Klaviyo Campaigns list before the product name. Defaults to 'Apify MCP Draft – \<today's date>' so successive runs never collide. Example: 'Q3 New Arrivals'.

## `includeAboutPage` (type: `boolean`):

When ON, the Actor tries /about, /about-us, and /pages/about on the first product's domain and feeds the page text to Claude as brand-voice context. Best-effort: if no About page responds within 8 seconds, generation proceeds without it (no failure). Useful for Shopify and DTC stores with a strong written brand voice. OFF by default to keep runs fast and predictable.

## `model` (type: `string`):

Model used to write the email copy. Routed through Apify's OpenRouter Actor proxy — you don't need a separate API key, your APIFY\_TOKEN is used. Claude Sonnet 4.6 is plenty for subject + preview + 800-char body. Switch to Opus 4.7 only if you need deeper brand-voice matching and don't mind ~10x the LLM cost (still cents per run for 20 emails).

## Actor input object example

```json
{
  "productUrls": [
    "https://www.allbirds.com/products/mens-wool-runners",
    "https://www.allbirds.com/products/mens-tree-runners"
  ],
  "klaviyoListId": "Yh5K8m",
  "fromEmail": "hello@yourbrand.com",
  "fromName": "New Arrivals",
  "campaignNamePrefix": "",
  "includeAboutPage": false,
  "model": "anthropic/claude-sonnet-4.6"
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per product URL — created draft campaign ID, template ID, generated copy, status, and any error info.

## `campaignDeepLink` (type: `string`):

Direct URL to the first newly created draft campaign in Klaviyo.

# 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 = {
    "productUrls": [
        "https://www.allbirds.com/products/mens-wool-runners",
        "https://www.allbirds.com/products/mens-tree-runners"
    ],
    "klaviyoListId": "Yh5K8m",
    "fromEmail": "hello@yourbrand.com",
    "fromName": "New Arrivals",
    "campaignNamePrefix": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("luis.pinto/klaviyo-campaign-drafter").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 = {
    "productUrls": [
        "https://www.allbirds.com/products/mens-wool-runners",
        "https://www.allbirds.com/products/mens-tree-runners",
    ],
    "klaviyoListId": "Yh5K8m",
    "fromEmail": "hello@yourbrand.com",
    "fromName": "New Arrivals",
    "campaignNamePrefix": "",
}

# Run the Actor and wait for it to finish
run = client.actor("luis.pinto/klaviyo-campaign-drafter").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 '{
  "productUrls": [
    "https://www.allbirds.com/products/mens-wool-runners",
    "https://www.allbirds.com/products/mens-tree-runners"
  ],
  "klaviyoListId": "Yh5K8m",
  "fromEmail": "hello@yourbrand.com",
  "fromName": "New Arrivals",
  "campaignNamePrefix": ""
}' |
apify call luis.pinto/klaviyo-campaign-drafter --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=luis.pinto/klaviyo-campaign-drafter",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Klaviyo Campaign Drafter",
        "description": "Turn product URLs into draft Klaviyo email campaigns. Scrapes each product, writes copy with Claude, creates a draft campaign per product via the Klaviyo MCP Connector. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "zi2LMdOfbANI5j0X8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/luis.pinto~klaviyo-campaign-drafter/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-luis.pinto-klaviyo-campaign-drafter",
                "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/luis.pinto~klaviyo-campaign-drafter/runs": {
            "post": {
                "operationId": "runs-sync-luis.pinto-klaviyo-campaign-drafter",
                "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/luis.pinto~klaviyo-campaign-drafter/run-sync": {
            "post": {
                "operationId": "run-sync-luis.pinto-klaviyo-campaign-drafter",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "productUrls",
                    "klaviyoConnector",
                    "klaviyoListId",
                    "fromEmail"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Product URLs",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Between 1 and 20 product page URLs. Each URL becomes one Klaviyo draft campaign — the Actor scrapes the title, description, price, and main image, then Claude writes a subject + preview text + email body. Use canonical product pages (NOT category, collection, or search-result pages), otherwise the scraper extracts noisy data. Mixing domains is fine (Shopify, BigCommerce, WooCommerce, Amazon, Walmart, etc.). Example: https://allbirds.com/products/mens-wool-runners. Tip: 5–10 products per run is a good batch size for review in the Klaviyo dashboard.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "klaviyoConnector": {
                        "title": "Klaviyo MCP Connector",
                        "type": "string",
                        "description": "Your connected Klaviyo MCP Connector. BEFORE running this Actor, create one in Apify Console > Settings > MCP Connectors > Add new connector > paste https://mcp.klaviyo.com/mcp > Authorize. Klaviyo's MCP supports dynamic OAuth client registration so you don't need to register your own Klaviyo developer app — one click and you're connected."
                    },
                    "klaviyoListId": {
                        "title": "Klaviyo list ID",
                        "type": "string",
                        "description": "The Klaviyo list or segment ID the draft campaigns will be addressed to. Find it in Klaviyo > Audience > Lists & segments > pick a list > copy the 6-character ID from the URL (looks like Yh5K8m). The campaigns are still drafts — they won't send until you click Send in the Klaviyo dashboard."
                    },
                    "fromEmail": {
                        "title": "From email address",
                        "type": "string",
                        "description": "Sender email address for the draft campaigns. MUST already be verified as a sending identity in your Klaviyo account (Klaviyo > Settings > Domains & sending) — otherwise the campaign can be created as a draft but won't be sendable. Example: hello@yourbrand.com."
                    },
                    "fromName": {
                        "title": "From name",
                        "type": "string",
                        "description": "The sender name recipients see in their inbox. Defaults to 'New Arrivals'. Keep it short — most inboxes truncate after ~25 characters. Examples: 'Allbirds', 'Casper Team', 'Sarah from Glossier'.",
                        "default": "New Arrivals"
                    },
                    "campaignNamePrefix": {
                        "title": "Campaign name prefix (optional)",
                        "type": "string",
                        "description": "Prefix shown in the Klaviyo Campaigns list before the product name. Defaults to 'Apify MCP Draft – <today's date>' so successive runs never collide. Example: 'Q3 New Arrivals'.",
                        "default": ""
                    },
                    "includeAboutPage": {
                        "title": "Use the brand's About page for tone",
                        "type": "boolean",
                        "description": "When ON, the Actor tries /about, /about-us, and /pages/about on the first product's domain and feeds the page text to Claude as brand-voice context. Best-effort: if no About page responds within 8 seconds, generation proceeds without it (no failure). Useful for Shopify and DTC stores with a strong written brand voice. OFF by default to keep runs fast and predictable.",
                        "default": false
                    },
                    "model": {
                        "title": "LLM model",
                        "enum": [
                            "anthropic/claude-sonnet-4.6",
                            "anthropic/claude-opus-4.7"
                        ],
                        "type": "string",
                        "description": "Model used to write the email copy. Routed through Apify's OpenRouter Actor proxy — you don't need a separate API key, your APIFY_TOKEN is used. Claude Sonnet 4.6 is plenty for subject + preview + 800-char body. Switch to Opus 4.7 only if you need deeper brand-voice matching and don't mind ~10x the LLM cost (still cents per run for 20 emails).",
                        "default": "anthropic/claude-sonnet-4.6"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
