> ## Documentation Index
> Fetch the complete documentation index at: https://docs.sequenzy.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Changelog
> What's new in Sequenzy
TikTok and Pinterest can now be saved under Product Info and added to the social
block, so their icons render in your emails alongside the platforms already
supported.
### Landing Page Favicons, Search Visibility, And Duplication
Three additions to **Page settings** and the landing-page list.
**Your favicon, not ours.** Published pages showed the Sequenzy icon in the
browser tab. Now you can upload a favicon per page, and any page without one
falls back to your workspace logo automatically, so a customer never sees
Sequenzy branding in the tab.
**Hide from search engines.** Pages on a verified custom domain are indexable by
default, which is wrong for private client previews and internal launches. Turn
on **Hide from search engines** and the page serves a `noindex, nofollow` tag so
Google and other crawlers keep it out of search results. The link keeps working
for anyone you share it with. Landing-page domains also no longer serve
Sequenzy's own robots.txt sitemap.
**Duplicate a page.** Copy a page you already like instead of rebuilding it. The
copy is created as a draft with its own slug and stats, and the original keeps
its published URL and metrics.
All three are available through the API, CLI (`sequenzy landing-pages
duplicate`), and MCP (`duplicate_landing_page`, plus `seo.faviconUrl` and
`seo.hideFromSearchEngines` on page content).
[View documentation](/concepts/landing-pages)
Transactional API sends can now disable click or open tracking per send with
the new `trackingSettings` field, useful when tracking redirects break universal
links. [View documentation](/concepts/tracking)
### See who is inside a sequence right now
Sequence stats have always told you how many contacts sit at each step. You can
now pull the contacts themselves. A new enrollments listing returns one row per
enrolled contact with their email, name, the node they are currently on, when
they entered the sequence, and when a waiting contact resumes.
Filter by step, status, subscriber, or email address, sort by soonest resume to
see who moves next, and page through the full list to export it. This answers
the question counts cannot: not "how many are waiting at Wave 1", but "who".
It is available on all three surfaces:
* API: `GET /api/v1/sequences/{sequenceId}/enrollments`
* CLI: `sequenzy sequences enrollments `, including `--all --csv` for a
one-command export
* MCP: `list_sequence_enrollments`
[View documentation](/api-reference/sequences/list-enrollments)
Email segment filters now accept `is` and `is_not` for exact, case-insensitive
address matching in the dashboard, API, CLI, and MCP, so allowlists and
exclusions of specific contacts no longer have to be built out of `contains`
filters. [View documentation](/concepts/subscribers)
`fromName` and `replyToName` can now be sent on their own through the API, CLI,
and MCP to rename the display name of your default From and Reply-To profiles
without changing the address, and the new `senderProfileId` / `replyProfileId`
fields pick exactly which profile becomes the default when one address carries
several display names. [View documentation](/api-reference/companies/update)
Sequence reads across the API, CLI, and MCP now return an unambiguous
`effectiveStatus` (`draft`, `live`, `enrollment_paused`, `paused`, `archived`)
so a sequence that is `active` with paused enrollment can no longer be mistaken
for one that takes new subscribers. [View documentation](/api-reference/sequences/list)
Windowed delivery stats are now a funnel over the sends made inside the period,
so open, click, and reply rates can no longer exceed 100% when older emails are
opened or replied to during the window.
[View documentation](/api-reference/analytics/metrics)
AI sequence generation now writes up to 10 emails at once instead of 3, and the
progress dialog lists every step in sequence order with its live status.
### Segment by Purchased Collection
Segment on a whole collection instead of one product at a time. Pick
"Purchased Collection" in the segment builder and the segment matches everyone
whose orders contain any product in it, with the same bought / didn't buy /
order count options as the product filter. Works retroactively against your
existing orders, and is available through the API, CLI
(`--commerce-collection`), and MCP.
Membership is evaluated against your catalog as it stands now, so moving a
product out of a collection also removes its past buyers from the segment.
[View documentation](/concepts/cli#segments)
### Bulk Sequence Cancellation, Bulk Tagging, and Test Events
Three lifecycle-migration gaps are now covered across the API, CLI, and MCP.
Sequence enrollments can be cancelled with `cancelAll: true` or a batch of
`subscriberIds`, which is the only way to stop contacts already mid-flight -
pausing a sequence just blocks new entrants. Bulk targets default to a dry run,
and `sequenzy sequences cancel-enrollments --all --apply` pages through
large cancellations for you. Tags can be added or removed across up to 500
existing subscribers per request; unknown identifiers come back in `notFound`
instead of creating contacts, and tag automations stay off unless you ask for
them. And the new `trigger_subscriber_event` MCP tools emit the same events an
integration would, so triggers, branch conditions, and stop conditions can be
tested without waiting for real traffic.
[View API documentation](/api-reference/subscribers/tags/bulk-add) ·
[View CLI documentation](/concepts/cli) ·
[View MCP documentation](/concepts/mcp)
### Read-Only Account Audit Tools
You can now check how an account is wired up without holding any write access.
Four read-only surfaces across the API, CLI, and MCP cover connected
integrations and their sync health, sender and reply-to profiles with the
sending domain behind each address, tracking and attribution settings, and a
campaign's resolved audience. The audience check is the one to reach for before
a send: it turns stored list and segment IDs into names, flags references to
deleted records, recomputes the recipient count at read time, and warns when
targeting is unset, because scheduling such a campaign sends to every active
subscriber. Integration credentials, access tokens, and webhook secrets are
never returned.
[View CLI documentation](/concepts/cli) - [View MCP documentation](/concepts/mcp)
### Render Emails to HTML for Your Own Preview
If you build your own dashboard or email builder on top of Sequenzy, you can now
fetch the rendered email instead of only its block JSON.
`POST /api/v1/campaigns/{campaignId}/render`,
`POST /api/v1/sequences/{sequenceId}/nodes/{nodeId}/render`, and
`POST /api/v1/templates/{templateId}/render` return the exact email-safe HTML
that would be sent, plus the resolved subject, preview text, and locale. The same
renderer powers real sends, so an embedded preview cannot drift from what
recipients receive.
Pass `subscriberId`, an inline `subscriber`, or nothing at all to render for a
sample contact, and `variantId` to preview an A/B test variant. Links stay clean
unless you pass `tracking: true`. All three endpoints are read-only. The same
capability is in the CLI as `sequenzy campaigns render` (plus `sequences` and
`templates`), and as the `render_email` MCP tool.
[View documentation](/api-reference/campaigns/render)
### Campaign Audience Before Scheduling
Campaigns managed through the API, CLI, or MCP can now save and change their
audience without scheduling a send. `POST /api/v1/campaigns`,
`PUT /api/v1/campaigns/{campaignId}`, `create_campaign`, and `update_campaign`
all accept `targetLists` (or the `segmentId` shorthand), and `update_campaign`
accepts `targetLists: null` to clear saved targeting again. In the CLI,
`sequenzy campaigns create` and `sequenzy campaigns update` accept `--segment`,
`--target-lists-json`, and `--target-lists-file`, `campaigns update` adds
`--clear-target-lists`, and `sequenzy campaigns schedule` now accepts
`--segment` alongside its existing target list flags. Campaign reads return the
saved audience as `targetLists`, and `campaigns create`, `campaigns update`, and
`campaigns get` print it on the `Audience` line.
[View CLI documentation](/concepts/cli)
### Undeliverable Mail No Longer Counts as a Bounce
A bounce means the receiving provider told us the mailbox is bad. Until now, a
message that simply ran out of delivery routes was recorded the same way, so a
temporary problem on our sending infrastructure could mark a perfectly valid
address as bounced, stop future sends to it, and count against your bounce
rate.
These are now separated. When every delivery route for a message is exhausted,
the message is marked **Delivery failed**, with the explanation "The recipient
provider rejected all currently available delivery routes." A failed send:
* does not suppress the address, so the contact stays subscribed and receives
your next campaign;
* does not count toward your bounce rate, or toward the automatic sending pause
that protects your sender reputation;
* reports as a new `email.failed` webhook event instead of `email.bounced`, so
your own systems can tell "we could not get through" apart from "this address
is invalid".
Genuine bounces are unchanged. An unknown mailbox still bounces, still
suppresses the address, and still counts.
**If you use outbound webhooks, check your subscription.** Sends that would
previously have reached you as `email.bounced` now arrive as `email.failed`.
Endpoints created from now on include `email.failed` in the default event set,
but existing endpoints keep the exact event list they were created with, so add
`email.failed` to yours if you want to keep hearing about undelivered mail.
Deliverability dashboards now also break out Comcast, GMX/WEB.DE, Proton and
many more Microsoft, Yahoo, Orange, Free and SFR domains by name instead of
lumping them into "Other". Existing history keeps whatever provider it was
recorded under, so charts step-change on the day this ships rather than being
rewritten.
### Anonymous Shopify Browsing Is Backfilled After Identification
Most shoppers browse your store and add items to their cart before ever
typing their email. Sequenzy's Shopify browse pixel now remembers that
anonymous activity in the shopper's browser (for up to 14 days) and
backfills it onto the contact the moment they identify - by entering their
email at checkout or signing in. Product views, add-to-carts, cart views,
collection views, and searches all land on the contact's activity timeline
with their original timestamps, so you see the full journey that led to a
checkout instead of a contact who seems to appear out of nowhere. Once
identified, later visits from the same browser are tracked in real time,
which also makes browse- and cart-abandonment automations work for
customers who first showed up anonymously. Backfilled historical events
never trigger event-received sequences, never advance a sequence a contact
is already in, and never send abandonment emails retroactively. They do
update segment membership, so a contact can still enter a segment-triggered
sequence if your segment matches the backfilled activity.
[View documentation](/integrations/shopify#anonymous-visitor-backfill)
### Sequences Now Run for Unsubscribed and Bounced Contacts
Unsubscribed and bounced contacts are no longer blocked from entering
sequences. When a trigger matches, they enroll like anyone else and move
through every step: tag changes, attribute updates, webhooks, and emails
marked as transactional (an order-shipped notification, for example) all
still run. Marketing email steps are skipped automatically for them, so
consent is never violated. Contacts who unsubscribe while already inside a
sequence keep the previous behavior - the remaining enrollment is cancelled.
This makes event-driven flows like order updates work for every customer,
whether or not they are subscribed to marketing email.
[View documentation](/concepts/sequences#unsubscribed-and-bounced-contacts)
### Whop Integration
You can now connect your Whop account to sync payments and memberships
straight into Sequenzy. Once connected, purchases, failed payments,
cancellations, and refunds flow in as subscriber events, and each matching
subscriber gets revenue attributes (`mrr`, `ltv`, `whopCustomerId`) you can use
to build segments and trigger automations - for example targeting high-MRR
customers or launching a win-back sequence when a membership churns.
Connecting takes a Whop API key with the member, email, payment, plan,
access-pass, phone, and promo-code read permissions listed in the setup guide,
plus a webhook pointed at your Sequenzy company. Existing customers and
memberships are backfilled automatically on connect, and you can trigger a
manual re-sync from the integration card at any time.
[View documentation](/integrations/whop)
### Immediate Campaign Cancellation
Cancelling a sending campaign now stops outgoing emails within seconds:
batches already being processed check for the cancellation before every email
instead of finishing their full batch first.
### Live Sequence Enrollment Stage Counts
Sequence metrics now include `enrollmentCounts`, a live snapshot of active and
waiting enrollment runs grouped by current node. The same breakdown is
available from the REST sequence metrics endpoints, `sequenzy stats --sequence`, and the MCP `get_sequence_stats` tool, so agents can answer “how
many are waiting at each stage?” without scanning subscribers individually.
Historical date filters still scope engagement metrics while enrollment counts
reflect current state.
[View sequence metrics documentation](/api-reference/analytics/sequence-metrics)
### Safe Step Deletion in Live Sequences
Deleting a sequence step no longer strands subscribers who are currently in
it. Anyone waiting inside a deleted step (a delay, a wait-for-event, or an
email step) now moves to the next step immediately and continues through the
sequence, matching the rewired flow new enrollees follow. The editor warns
you before the delete when people are in the step, and the sequence canvas
now shows a notice if any subscribers are stuck on a step that was removed
in the past. The same behavior applies to sequence edits made through the
API and MCP, which report how many recipients were moved. Existing deletion
protections still apply to trigger and end steps and to active or generating
A/B tests. For otherwise-deletable steps, recipient migration is refused when
people are in a branch step and multiple paths survive, since there is no
single next step to move them to.
[View sequences documentation](/concepts/sequences)
### Account-wide API Keys
Account Settings now has an API Keys page for creating and revoking personal
`seq_user_` keys. One account key can work across every workspace the user can
access, including newly created workspaces; API requests select the target with
the `x-company-id` header. Permission presets still apply, so multi-workspace
automation can be limited to read-only, data-ingest, transactional, safer-agent,
or full access. Viewer memberships remain read-only even if the account key has
broader permissions.
[View authentication documentation](/authentication)
### Reliable Cart Abandonment Trigger
Cart recovery no longer depends on shoppers visiting the cart page. Sequenzy
now maintains a live cart snapshot for every known shopper from add-to-cart,
remove-from-cart, and cart-view activity (Shopify web pixel and the
WooCommerce plugin). Each cart change restarts an inactivity timer; once the
cart sits untouched for the configured window (1 hour by default) with no
checkout or order, the new **Cart Abandoned** trigger
(`ecommerce.cart_abandoned`) fires with the full cart - every line item with
title, variant, quantity, price, image, and product URL - so recovery emails
always show the complete cart, not just the last product added. Starting a
checkout or placing an order cancels the pending trigger, and a per-shopper
cooldown prevents repeat sends. Timing and cooldown are configurable per
store in the Shopify integration settings and via the API
(`/api/v1/shopify/automation-settings`), CLI (`sequenzy shopify settings`),
and MCP. The Abandoned Cart Recovery sequence template now uses the new
trigger, and the legacy `ecommerce.cart_started` event (which only fired on
cart-page views) keeps working for existing automations but is no longer
offered for new ones.
[View documentation](/concepts/events)
### Direct Sequence Step Test Sends for Agents
Agents can now send any saved sequence email step straight to one or more
internal reviewers without copying it into a temporary campaign. The MCP
`send_sequence_test_email` tool accepts a sequence ID, email-step node ID, and
up to ten reviewer addresses. The REST API and `sequenzy sequences test` CLI
command expose the same workflow, returning a durable email send ID for each
recipient so delivery problems can be inspected directly.
[View documentation](/api-reference/sequences/send-test)
### Send API Engagement Metrics
Send API open and click rates are now available through the account metrics API
with `emailType=transactional`, the CLI with
`sequenzy stats --email-type transactional`, and the MCP `get_stats` tool with
`emailType: "transactional"`. This includes direct and saved-template sends;
the returned `emailSendId` still provides the delivery-level status and event
timeline through the email-sends API, CLI, and MCP tool.
[View documentation](/api-reference/analytics/metrics)
### Searchable Delivery History and Per-Email Stats
The recent sent-email history is now queryable by subject/title, recipient,
delivery status, email type, bounce type, date window, and source across the
REST API, CLI, and MCP. Returned delivery IDs drill into exact open/click
timestamps and events. Saved transactional emails also have dedicated
aggregate metrics by ID or slug, with optional time windows.
Transactional template lists can now search name, slug, or subject, filter
active state, and sort by sends, opens, clicks, open rate, or CTR across REST,
CLI, and MCP. Per-template stats now include top clicked links, complaints,
replies, permanent/transient bounce details, and human-versus-machine
engagement. The CLI can export the complete filtered delivery history with
`email-sends list --all --csv email-sends.csv`, and CLI/MCP delivery results
include direct dashboard URLs.
[List sent emails](/api-reference/email-sends/list) · [View transactional email metrics](/api-reference/analytics/transactional-metrics)
### Scheduled Campaigns Can Return to Draft
Scheduled campaigns can now be unscheduled without permanently cancelling and
recreating them. The dashboard, public API, CLI (`campaigns unschedule`), and
MCP (`unschedule_campaign`) all remove the pending send and recurrence, return
the campaign to an editable draft, and preserve its content and audience.
[View documentation](/api-reference/campaigns/unschedule)
### Subscriber Names in Transactional API Sends
Single-recipient transactional sends now use the matched subscriber's saved
first and last name when the API request omits those variables. Matching works
with `subscriberExternalId` or the recipient email, and explicit request
variables still take precedence. Multi-recipient sends remain shared messages
and do not borrow one subscriber's profile.
[View documentation](/api-reference/transactional/send)
### Per-Enrollment Sequence Attachments
Event-triggered sequences can now attach a different file for every enrollment.
In an email step, choose **From trigger** and use an event URL such as
`{{event.file_url}}`; filenames can also use event values, for example
`file-{{event.order_id}}.pdf`. Sequenzy resolves values from the original
enrollment event, validates the final public URL and filename, and fetches the
file when the email sends. The same `{ filename, path }` templates work through
the sequences API, CLI, and MCP tools.
[View documentation](/concepts/sequences#file-attachments)
### Per-Customer Predictive Analytics
Every customer with order history now gets individual predictions computed
nightly from your store's buying patterns: predicted spend over the next 12
months (`predictedLtv`), churn risk (`churnRisk`), expected next order date
(`expectedNextOrderAt`), and typical order cadence (`avgDaysBetweenOrders`).
Predictions are stored as ordinary subscriber attributes, so they work
everywhere attributes do - segment filters (including relative dates like
"expected to reorder in the next 7 days"), campaign targeting, subscriber API
and CLI responses, and the MCP `get_subscriber` tool - and each subscriber's
profile shows a Predictions panel with confidence and freshness. Three
predefined segments ship with it: At-risk customers, Predicted VIPs, and Due
to reorder soon. Two new automation events, `ecommerce.reorder_window_missed`
and `ecommerce.churn_risk_elevated`, fire once per order cycle so winback and
at-risk sequences trigger on each customer's actual buying cadence instead of
a fixed delay. Works with Shopify, WooCommerce, and Commerce API order
sources. [View documentation](/concepts/predictive-analytics)
### Product Recommendations: First-Class Block, Ranking Strategies, and Revenue Attribution
Personalized product recommendations are now a first-class part of Sequenzy.
A new **Recommended products** block in the email editor's Commerce section
drops in a ready-made product list that picks different products for every
recipient at send time - no configuration required.
You can now choose how products are ranked: **Personalized for each
recipient** (browsing activity first, then similar shoppers, then
store-popular products), **Best sellers** by recent order volume, **Newest
products**, or **Recently viewed**. Activity-based strategies accept a
configurable activity window.
Recommendations now report their own funnel. Campaign and sequence stats show
how many recommended products were shown and clicked, plus attributed orders
and revenue - an order counts when a subscriber buys a recommended product
within 7 days of clicking it - along with a per-product breakdown. The same
time-range-aware numbers are available from the API (`recommendations` on
campaign and sequence metrics), the CLI, and the MCP `get_campaign_stats` and
`get_sequence_stats` tools. Revenue totals stay separated by order currency.
[View documentation](/concepts/product-recommendations)
The dashboard now includes an "Ask Your Agent" section with copy-ready
prompts - like analyzing customer LTV or building high-ROI sequences - that
you can paste into any AI agent connected to Sequenzy via MCP, the CLI, or
the API.
Plain emails are now truly minimal - text, one clear call to action, and
at most a discount code on offer emails - across AI generation and the
Classic campaign template gallery, while designed styles keep their rich
layouts, making the two clearly distinct.
### Visibility for Skipped Sequence Enrollments
When an unsubscribed or bounced contact triggers an event that matches an
active sequence, the skip is no longer silent. The dashboard activity feed
marks the contact and shows "Would trigger if subscribed" on the matching
sequence instead of "Triggered", the sequence trigger step shows a skipped
count, and the contact's activity timeline records an "Enrollment skipped"
entry with the reason. Sequence stats also expose the skip counts through the
API (`enrollmentSkipped` on `GET /api/v1/metrics/sequences/{sequenceId}`), the
CLI (`stats --sequence`), and the `get_sequence_stats` MCP tool.
Deleting a user in a connected auth provider (Supabase, Clerk) unsubscribes
the contact, and that specific unsubscribe is now reversible by the same
provider: re-creating the user reactivates the contact automatically. Explicit
opt-outs (unsubscribe link, dashboard, API) are never undone.
[View documentation](/integrations/supabase#user-lifecycle)
Dashboard pages now show content-shaped loading skeletons instead of
spinners, so navigating between campaigns, sequences, subscribers, and other
screens feels smoother and less jumpy.
### Dynamic Carts in Generated Recovery Emails
AI-generated abandoned cart and abandoned checkout sequences now render each
recipient's actual cart. Generated emails include a dynamic item list bound to
the trigger event's line items (product image, title, quantity, and formatted
price resolve per recipient at send time), and checkout recovery CTAs link to the
recipient's personal resume-checkout URL when the commerce source supplies
one, with the brand's cart page as a safe fallback. This applies to the
prebuilt Abandoned Cart and Abandoned Checkout templates and to any cart or
checkout event-triggered sequence generated via the dashboard, API, CLI, or
MCP. Consecutive recovery steps now rotate through stable, recovery-specific
item layouts instead of repeating the same card treatment; visual emails use
card-row, editorial-row, product-grid, and receipt-row presets, while plain
emails use restrained thumbnail, receipt, and subtle-card variants. Checkout
events use a consistent optional `checkoutUrl` contract, and
order events sync a `lastOrderAt` subscriber attribute for recency-based
personalization.
The sequence editor now shows a persistent chip on the canvas whenever a
sequence is not active, with a one-click Activate action - so a freshly
generated draft is never mistaken for a live automation.
### Predictive Commerce Analytics
Shopify order history and live commerce orders now power explainable predicted
AOV, predicted 12-month customer value, and a 90-day order and revenue
forecast. The Metrics dashboard shows confidence-aware ranges and reports the
exact data still needed instead of estimating from sparse history. The same
forecast is included in `GET /api/v1/metrics`, `sequenzy stats`, and the MCP
`get_stats` tool. Forecasts use provider-neutral commerce order events, so the
model also works with WooCommerce and Commerce API orders.
[View analytics API documentation](/api-reference/analytics/metrics)
### File Attachments on Sequence Email Steps
Sequence email steps can now include real file attachments - ideal for lead
magnets and guides delivered by event-triggered sequences. Attachments are
URL-backed: provide a public HTTPS URL and a filename, and Sequenzy fetches
the file at send time and attaches it to the email, so you can update the file
at its source without editing the sequence. In the dashboard, upload a file
from the email editor's settings (gear) menu - Sequenzy hosts the upload for
you. You can also set `attachments` on
email steps through the sequences API, the CLI's step JSON, and the
`create_sequence` / `update_sequence` / `update_sequence_node` /
`insert_sequence_step` MCP tools. Up to 10 attachments and 7MB total per
email. Most email platforms don't support attachments in automated flows at
all - for broad marketing sends, a hosted download link is still the
deliverability-friendly default.
[View documentation](/concepts/sequences#file-attachments)
### Email Theme in API, CLI, and MCP
The company default email theme - preset, colors, typography, and layout - can
now be updated through the public API, CLI, and MCP server, not just the
dashboard. `PATCH /api/v1/companies/{id}` accepts an `emailTheme` object,
`companies update` gains `--email-theme-json` / `--email-theme-file`, and the
`update_company` MCP tool accepts the same field. Updates are partial: omitted
fields keep their current value, numeric values are clamped to supported
ranges, and passing `null` resets the theme to the platform default.
[View documentation](/api-reference/companies/update)
The email preferences page now shows a clear Unsubscribe button (and a
Resubscribe option after unsubscribing) when a company has no public
subscriber lists, instead of an empty page with no way to opt out.
Saved templates can now have their inbox preview text updated through REST,
the `sequenzy templates update --preview-text` CLI option, or MCP's
`update_template` tool without opening the dashboard.
The default footer text and link color in sent emails is now darker
(`#6b7280` instead of `#9ca3af`) so unsubscribe links and the subscription
reason stay readable on the default white email background. Footer background
choices and custom colors are unchanged.
### Full Sequence Authoring Parity for API, CLI, and MCP
`insert_sequence_step` can now create `logic_wait_for_event` and
`logic_branch` nodes with typed arguments. Branch paths can atomically wire to
existing node IDs - including the sequence completion node - with
`targetNodeId` and `elseTargetNodeId`, while still supporting newly created
path steps. This makes flows such as “reply in this sequence → complete,
otherwise → send the follow-up” possible without creating a dashboard node and
then replacing the graph in a second call. The REST API and CLI branch JSON use
the same target fields, and target-aware writes reject cycles or disconnected
flows before anything is saved.
The same public surfaces now cover every dashboard sequence setting: inbound
webhook triggers, descriptions, labels, recipient cancellation, typed stop
condition matching, segment-exit behavior, sequence and per-step delivery
identity, transactional emails, and CC/BCC recipients. Typed insertion also
covers delays, conditions, tag/list actions, subscriber updates, discounts,
outbound webhooks, SMS, wait nodes, and branches. Sequence email nodes can be
converted into A/B tests with independent variants, and sequence-level
duplicate, archive, and restore actions are available through REST, CLI, and
MCP.
Sequence authoring can now also start from a blank dashboard-compatible draft,
atomically replace trigger types, configure and rotate inbound-webhook
endpoints, manage persisted event or subscriber-attribute conversion goals,
filter the sequence list by status/search/labels, and read the user attribution
for enrollment pauses. REST, CLI, and MCP expose the same typed contracts.
API keys can now be safely cleaned up after a failed secret handoff. The public
API, CLI, and MCP server can list company keys as non-secret metadata and revoke
an exact key by ID. `list_api_keys` never returns the plain key or stored hash;
`revoke_api_key` is canonical and `delete_api_key` remains available as an
alias. The CLI provides matching `api-keys list` and confirmed `api-keys
revoke` / `delete` commands.
Workspace settings now open on the Domain tab, and the old Product Info page is split into focused tabs: Product Info (name, logo, social links, legal details), AI Context (tone, company context, value props, testimonials, pricing tiers), and Email Design (default email theme). The primary email language and text direction now live on the Localization tab alongside translations.
Event pickers in sequence triggers, goals, and subscriber filters now sort events by how often they fired in the last 24 hours and show the count next to each event. Event pickers also only offer the built-in events that match your business - SaaS lifecycle events are hidden for ecommerce stores and ecommerce events are hidden for SaaS products.
Revenue attribution is now more accurate: clicks always beat opens for last-touch credit (as documented), automatic opens from privacy proxies and security scanners no longer earn attribution, and goals with attribution windows longer than 24 hours now report every conversion recorded inside their configured window.
Sequence email Format updates through the API, CLI, and MCP now work for native
block emails that contain supported custom HTML blocks, such as an HTML footer
component. Only emails stored entirely as standalone raw HTML remain excluded.
The PostHog integration now updates subscriber attributes only for `$identify` events. Identify profile data (`$set`, `$set_once`, and person properties) is synced, while all other event properties stay on the event and are no longer copied onto the subscriber profile.
### Sequence Email Format in API, CLI, and MCP
Sequence reads now return each linked email's effective `emailPreset`, matching
the dashboard's **Style > Format** setting. API, CLI, and MCP updates can set a
native-block email to `minimal` or `branded` without changing the company theme,
using the same block transformation as the dashboard. Raw HTML emails are left
unchanged and do not support format updates.
"Start from scratch" in campaigns, sequences, and transactional emails now expands into an AI prompt with suggestion chips - describe what you want and land in the editor with the draft already generating, or keep using the plain empty editor via the link below the prompt.
### Editorial Block Styles: New Buttons, Pull Quotes, Captions, and More
A set of editorial upgrades across the core email blocks, so emails can feel
designed without leaving the block editor:
* **Two new button styles**: **Ink**, a near-black fill that pairs with any
brand color, and **Link**, a quiet letterspaced-caps text link with a
trailing arrow for secondary actions.
* **Editorial testimonial**: a large serif pull quote set between thin
hairline rules, alongside the existing card, minimal, centered, and quote
layouts.
* **Image captions and frames**: add a small muted caption under any photo,
and frame it with a hairline border or a white gallery mat.
* **Numbered headings**: give a heading an oversized index like "01" for
numbered editorial sections.
* **Ready-made editorial components in the block menu**: Framed Box,
Numbered Heading, Editorial Quote, Ledger table, Matted Photo, the new
button styles, and dots/accent dividers are all one click (or one `/`
command) away.
Everything renders identically in the editor, the preview, and the sent
email, and stays Gmail and Outlook compatible. The AI email writer can use
all of the new styles too, and the designed template gallery already puts
them to work - museum-mat product shots, serif pull quotes, ink buttons,
and numbered bulletins across the collections. Every designed template now
uses typographic numbered steps and clean detail ledgers instead of number
circles and tinted tiles, so the whole gallery shares one editorial
language. Three new templates are
built entirely around the editorial components: **The Gallery Wall**
(product photography hung like framed prints), **The Index** (a numbered
table-of-contents newsletter), and **The Postcard** (a matted photo and a
handwritten-feel note). [View documentation](/concepts/visual-blocks)
### Visual Template Gallery with Live Previews
The Designed campaign template gallery now shows a real rendered preview of
every template - each card displays the actual email with your brand color,
logo, and imagery applied, so you pick by look instead of by name. The
designed templates themselves were also reworked with editorial typography,
larger photography, and warmer layouts across all twelve collections.
### Subscriber Contact Changes in the Activity Timeline
The subscriber activity timeline now records a "Contact updated" entry whenever a subscriber's first or last name changes, showing the old and new value and which write path (API, dashboard, automation, import, or sync) made the change.
Popup and form builder improvements: the template galleries doubled to eight redesigned popup templates (including exit intent, live demo, announcement bar, and fullscreen welcome) and eight form templates (including demo request, email course, blog banner, and floating bar), template previews now show your company logo, fields can use full or half-width responsive layouts and show or hide their labels, countdown blocks get a date picker, popup success screens show only your success content, and popups with a side image now stack to a single column on mobile.
The template galleries also grew to twelve forms and twelve popups, and every template now has its own typography and shape - serif, monospaced, or sans headlines, sharp or generously rounded corners, and compact to spacious layouts - while all of them share your workspace brand colors, the same way landing page templates differ without changing your palette. New templates include a monospaced dev changelog, a serif Sunday essay, a sharp-cornered studio form, an extra-rounded club signup, a monospaced launch modal, a serif slide-in digest, a stripped-back fullscreen takeover, and a slim top-of-page announcement bar.
Also for forms and popups: field settings gained a "Saves to" picker so a field can write to the subscriber's first name, last name, or phone (or to a custom attribute with your own key) instead of everything landing in custom attributes, and the confirmation page shown after a native HTML form post now mirrors your form's success screen with its checkmark, heading, and message. Applying a saved form to a landing page now carries every field over - phone maps onto the subscriber profile, and choice, consent, and hidden fields become native landing-page form fields instead of being skipped.
The MCP `add_subscriber` and `update_subscriber` tools now accept native `firstName` and `lastName` fields, and `sequenzy subscribers update` gained matching `--first-name` / `--last-name` flags, so agents no longer need to store names as custom attributes.
### One Canonical Way to Create Sequences
`create_sequence`, `POST /api/v1/sequences`, and
`sequenzy sequences create` are now the canonical sequence-creation surfaces.
The older `generate_sequence`, `POST /api/v1/generate/sequence`, and
`sequenzy generate sequence` names are deprecated compatibility aliases. They
now persist the same disabled sequence draft instead of returning unsaved
preview content, and their responses or command output include migration
guidance. Existing aliases remain available so integrations do not lose their
route or command unexpectedly.
### CC and BCC Recipients on Every Email
You can now add CC and BCC addresses to campaigns, individual sequence steps,
and transactional templates. In any email editor, click the **CC/BCC** arrow
next to the Reply field to reveal the recipient inputs - they stay hidden
until you use them. Each configured address (up to 10 per list) receives a
copy of every email sent, which is useful for compliance archives, CRM
ingestion, or keeping a teammate in the loop. The recipient themselves is
never copied, and addresses duplicated between CC and BCC are sent only once.
Sequence steps combine their own BCC list with the sequence-level BCC setting,
and transactional templates merge their saved CC/BCC with any `cc`/`bcc`
passed on the API request. Campaign CC/BCC can also be set via the API and
MCP with the `ccEmails` and `bccEmails` fields on campaign update.
### Static-Site Signup Forms and Forms MCP Tools
Saved Forms now have a dedicated **Static site / Form action** embed option.
Copy the public action URL, a minimal native form, or a fetch enhancement for
Astro, Hugo, Jekyll, Cloudflare Pages, Netlify, and GitHub Pages. These embeds
need no backend proxy or browser-side API key: the saved form keeps its lists,
tags, duplicate handling, and success action on the server. The hosted
JavaScript embed is also available to every workspace user instead of being
limited to global admins.
MCP agents can now use `list_forms`, `create_form`, and `get_form_embed` to
configure a list-scoped form and return working embed code. Integration-guide
requests for static frameworks use this Forms workflow and never recommend a
secret Bearer key in client code. [View signup form
documentation](/widgets/signup-form)
### Two-Way Per-List Consent Webhooks
Keep application-owned communication preferences in sync without polling.
Outbound webhooks can now subscribe to `subscriber.list_subscribed` and
`subscriber.list_unsubscribed`. Each signed event includes the event ID and
timestamp, subscriber ID, email and external ID, list ID and name, whether the
subscriber was added or removed, and the source of the change.
Events cover actual transitions made from subscription preferences, the
dashboard, API and MCP operations, automations, imports, double opt-in, and
integration-created memberships. Repeating an already-applied change does not
emit a duplicate transition. Global opt-outs continue to use
`subscriber.unsubscribed`. [View outbound webhook documentation](/integrations/outbound-webhooks)
### Segments, Events, and More in Conditional Blocks
Conditional (if/else) blocks and per-block **Conditional Display** rules can
now target much more than attributes and merge variables. You can show or hide
content based on segment membership, custom events (for example "performed
`purchase` in the last 30 days"), tags, lists, subscription status, engagement
(opened or clicked recently), Stripe and store purchases, signup date, email
provider, phone presence, and SMS status - the same filters you already use to
build segments.
Each rule is evaluated against live subscriber data at send time, so one email
can greet VIP customers with a different offer than everyone else. Recipients
that cannot be matched (for example a transactional recipient who is not a
subscriber yet) see the OTHERWISE branch. The editor preview shows the IF
branch by default; use the branch flip control to check the other one.
[View documentation](/concepts/campaigns)
### Programmatic Template Localization
Localized template variants can now be managed without opening the dashboard.
The REST API, CLI, and MCP can all store caller-supplied translations or queue
Sequenzy's AI translation for selected locales. Manual variants accept either
raw HTML or native Sequenzy blocks, preserve canonical locale handling, and are
immediately available to locale-aware campaign, sequence, and transactional
sends. Explicit sync works even when automatic on-save translation is disabled.
[View localization documentation](/concepts/email-localization)
### See Which Links Got Clicked in a Campaign
Campaign analytics now show a **Clicked Links** breakdown for sent campaigns:
the top tracked links in the email, ranked by clicks, with each link's share
of campaign-wide clicks. When the originating element can be resolved, the row
shows the button text, image, or text link in your email, with the destination
URL underneath; otherwise it shows the destination URL. When several links
share a destination, the row names all of them. Click any row to open the
destination. Find it in the campaign analytics view switcher, next to the
Sent Emails, Globe, and Engagement Over Time views.
The breakdown is also available outside the dashboard: the
[campaign metrics API](/api-reference/analytics/campaign-metrics) returns a
top-level `clickedLinks` array, `sequenzy stats --campaign ` prints a
Clicked Links section in the CLI, and the MCP `get_campaign_stats` tool
includes the same array for agents.
### More Accurate Click Counts
Click tracking now only wraps real links (anchors, image maps, and Outlook
button fallbacks). Previously, font stylesheet references in the email head
could be routed through click tracking, so email clients fetching fonts while
rendering registered phantom clicks. Font CDN fetches are also classified as
non-human engagement retroactively, so click counts and click rates for
past campaigns clean up automatically.
### Upload Email Images Directly from MCP
MCP agents can now upload screenshots and other email images without opening
the dashboard. `upload_image_asset` accepts a local image path from stdio MCP
clients or base64 bytes from remote-capable clients, saves the file in the
workspace's shared media library, and returns both the hosted URL and a
ready-to-insert image block. Alt text, responsive width, alignment, intrinsic
dimensions, and fixed-height `cover`/`contain` crops can be set in the same
call, so lifecycle screenshots use one precise treatment across editor preview
and sent email. PNG, JPEG, GIF, and WebP images up to 5MB are supported.
[View MCP documentation](/concepts/mcp)
### Custom Email Locales
You can now use locale codes beyond the built-in language picker for both your
company's primary email language and additional localized variants. Enter a
standard locale such as `fr-CA`, `sr-Latn`, or `en-AU`; Sequenzy validates and
normalizes the code, uses its language in AI writing and translation prompts,
and keeps existing variants stored under deprecated aliases such as `iw`
available under their modern locale (`he`). The language picker also includes
more ready-to-select languages, including Amharic, Bengali, Bulgarian,
Croatian, Persian, Serbian, Swahili, and Tamil.
[View documentation](/concepts/email-localization)
### Agent Handoff Prompts Now Include Setup Instructions
Prompts from the **Open in** menu in the sequence builder and email editor
sidebars are now self-sufficient. If the agent you hand off to is not
connected to Sequenzy yet, the prompt itself tells it how to get access:
add the remote MCP server in the agent's connector settings (with per-client
setup guides for ChatGPT, Claude, and Cursor), or use an API key from
**Settings → API Keys** against the REST API. The prompt also names your
workspace so the agent picks the right company. The MCP docs now include a
ChatGPT connector setup guide as well.
[View documentation](/concepts/mcp)
### Edit Any Existing Sequence Node from MCP
MCP agents can now patch existing sequence nodes in place instead of rebuilding
a flow. `update_sequence_node` handles one focused edit, while
`update_sequence_nodes` applies a batch atomically - including the common case
of changing every 5-minute delay to 7 days. Both tools work across stored node
types, including delays, email and SMS content, actions, conditions, webhooks,
branch configuration, and triggers. `get_sequence` supplies each node's current
config and `updatedAt` value plus `updateHints` with its editable and managed
fields for type-aware, concurrency-safe edits.
Node type conversion and topology remain explicit graph operations through
`edit_sequence_graph`. Active-sequence node edits require confirmation, and
recipients already waiting keep their previously scheduled time. [View MCP
documentation](/concepts/mcp)
### Polls & NPS Surveys in Emails
Ask a question, get one-click answers. The new **Poll** block renders answer buttons (up to 8, emoji welcome) and the **NPS Survey** block renders a 0-10 recommendation scale - both look identical in the editor, the preview, and the sent email, and work in every email client because each answer is a plain link.
* **Feeds segmentation directly**: every answer is saved to a subscriber attribute you choose (NPS scores as numbers, so segments can filter e.g. `nps_score` at most 6 for detractors) and appears in the subscriber's activity feed.
* **Automate follow-ups**: each vote fires a `poll.answered` event you can use in Event Received sequence triggers and sync rules - thank promoters, win back detractors.
* **Bot-proof**: clicks from security scanners and link-preview bots are filtered out, and re-votes simply update the stored answer.
* **After voting**: recipients land on a hosted thank-you page with your custom message (previewed live in the block settings), or redirect them to any URL.
* **Eight visual styles**: Soft, Pill, Outline, and Filled buttons, plus four designed looks - Pop (hard-shadow boxes), Brutal (square uppercase slabs with ink shadows), Quiz (A/B/C letter badges), and Minimal (a bare ruled list with accent arrows). The style picker previews each one in your accent color.
* **Results where you expect them**: sent campaigns show a Poll Results card with the answer distribution, and NPS surveys get the score with the promoter / passive / detractor split. Click any answer row - or the promoter / passive / detractor counts - to open the exact historical subscribers behind that campaign and poll block, even if their current stored answer later changes. The same summary is returned by the campaign stats API, CLI, and MCP as a `polls` array; MCP can recreate the drill-down with the campaign-and-block-scoped `pollResponse` segment filter.
* **Tamper-proof and deduplicated**: every answer link is cryptographically signed, and re-clicks of the same answer never re-fire your automations.
* **Push answers anywhere**: subscribe an outbound webhook to the new `poll.answered` event.
Insert it from the block menu or type `/poll` or `/nps`. Poll blocks are also supported in emails created via the API, CLI, and MCP, and the AI email writer can generate them. The hosted thank-you page follows your company's email language. [View documentation](/concepts/polls)
### Custom Event Setup Returned With New Sequences
Creating a custom-event sequence through the API or MCP now returns everything needed to connect the application-owned event feed: ready-to-adapt tracking code, the exact event payload contract, matching-field properties, a generated example payload with an explicit filter-match status and adaptation note when needed, the event endpoint, a direct documentation link, and the arguments for the MCP integration-guide tool. The MCP result keeps this guidance after its sequence readback instead of dropping it.
### Per-Step Sender Identity for Sequence Emails via API, CLI, and MCP
Individual email steps in a sequence can now get their own sender identity through the API, CLI, and MCP - not just in the dashboard editor. Pass `senderProfileId` or `fromEmail` (plus optional `fromName`), and `replyProfileId` or `replyTo` (plus optional `replyToName`) on any item in the `emails`/`steps` array of the update sequence endpoint, or on email steps inserted with `insertSteps`. A `fromName` on its own changes only the visible display name without touching the sender profile.
New email steps inserted into an existing sequence also now inherit the effective sender identity of the nearest sequence email, so added steps send as the same person as their neighbors. After a branch merge, only identity fields shared by every incoming path are inherited; conflicting fields use the sequence or company defaults. [View documentation](/api-reference/sequences/update)
### Restructure Existing Sequence Graphs from MCP
Agents can now move, reorder, reconnect, delete, and duplicate existing
sequence nodes instead of only inserting new steps. The new
`edit_sequence_graph` MCP tool can move an A/B test below a branch convergence,
deep-copy an A/B test with independent variants and emails, splice out linear
steps, or atomically replace the full edge topology for advanced reconnects.
`get_sequence` now returns edges plus a graph revision, and every graph edit
checks that revision before writing so a stale agent cannot overwrite a newer
change. Active-recipient and topology safeguards prevent destructive edits from
stranding live runs. [View sequence update API](/api-reference/sequences/update)
### Segment by Number of Opens and Clicks
Engagement filters can now count, not just check. Pick "opened at least" or "clicked at least" (or their "less than" counterparts) on any engagement filter and enter a count with a time window - `10:30d` for 10+ times in the last 30 days, or `10:all` for 10+ times ever. This unlocks segments like "best clickers - clicked more than 10 times" or "opened 10+ emails but never clicked" for catching bot and spamtrap opens. The value picker suggests count-and-range combinations as you type, the AI filter builder understands phrases like "clicked more than 10 times", and the same `count:timeRange` values work in segments created via the API, CLI, and MCP. [View documentation](/concepts/subscribers)
### Real Event Data in Previews and Test Sends
Emails inside an event-triggered sequence now preview `{{event.*}}` merge tags with values from the most recent matching event, instead of showing fallbacks or blanks. Test sends from the sequence email editor include the same sample payload, so the email you receive matches what a live send would render. Every prefilled value stays editable in the preview data panel, and anything you type there wins over the sample. [View documentation](/concepts/events)
### Event Variables in Update Subscriber Steps
Sequence "Update Subscriber" steps can now set field values from the payload of the event that started the sequence. Type `{{` in any value field to autocomplete variables like `{{event.plan}}` or `{{event.amount}}`, drawn from the trigger event's recent payloads - subscriber attributes (`{{subscriber.company}}`) and built-in fields (`{{firstName}}`, `{{email}}`) are suggested too. Variables resolve when the step runs; number fields accept variables and coerce the resolved value, and a field whose event property is missing is skipped instead of being blanked. Works the same for sequences created via the API, CLI, and MCP.
### Affonso Affiliate Integration
Connect your [Affonso](https://affonso.io) affiliate program to Sequenzy and run your affiliate communications from the same place as the rest of your email.
* **Affiliates sync as subscribers** with their tracking code, status, program, coupon code, and any custom metadata from your signup form.
* **Existing affiliates and performance totals are backfilled on connect** with a read-only Affonso API key, without replaying historical automation events or enrolling them into sequences.
* **Running totals per affiliate**: leads referred, conversions, total referred revenue, commission earned, and total paid out are kept up to date as attributes, so you can segment affiliates by performance (for example, referred revenue over \$1,000). The read-only API key needs Affiliates, Referrals, and Commissions read permissions.
* **Automate the whole lifecycle** with provider-agnostic `affiliate.*` events: welcome new affiliates on `affiliate.created`, celebrate wins on `affiliate.referral_converted`, and confirm payments on `affiliate.payout_paid`, with event details like `{{event.amount}}` available in your emails. Attribute and event names are not tied to Affonso, so your automations and segments keep working if you ever switch affiliate platforms.
Connect it in Settings → Integrations → Affiliate Marketing, then paste an Affonso API key and the signing secret from Affonso's webhook settings. Every webhook is signature-verified. [View documentation](/integrations/affonso)
### Designed Template Gallery
The campaign template picker now has a second, visual-first gallery: 88
designed templates built on the visual block set - photo heroes, lookbooks,
magazine-style digests, pricing cards, countdown sales, polls, and more,
organized into twelve categories from Welcome to Product News. The classic
functional templates stay the default; flip the new Classic/Designed switch
in the picker to browse them.
Four of the categories are wilder by design. Statement templates are
typographic and poster-like (a manifesto, a brutalist bulletin, three
stacked headline bands, a one-word email). Playful ones behave like games
(subscriber bingo, a pop quiz, a "do not open" mystery, a \$0.00 receipt
from the future). Cinematic ones read like film scenes (a heist briefing, a
midnight drop, a museum label, a mission launch). Avant-Garde ones borrow
formats from other mediums entirely (a boarding pass, a tasting menu, a
founder interview, a transmission from 2049).
Designed templates personalize themselves from your brand: your logo, brand
colors, harvested website imagery, synced products, and real customer
testimonials drop into the layouts automatically, with curated stock
photography as the fallback. Templates also carry distinct corner styling -
editorial layouts run square corners, playful ones extra-soft rounding - so
the gallery doesn't feel like one email repeated 56 times.
Template previews now resolve personalization fallbacks too, so
`{{FIRST_NAME|there}}` shows as "there" instead of a raw tag.
[View documentation](/concepts/visual-blocks)
### Prompt Creation Parity
Campaigns, saved templates, and transactional templates now accept prompts directly across the API, MCP, and CLI. Prompt creation uses the same branded native-block generator as the dashboard; campaigns remain drafts and prompt-created transactional templates default to disabled. Existing blocks and preserved HTML modes remain supported.
### Smoother Editing for Imported HTML Emails
A round of fixes that make the HTML editor (used for imported emails) behave
like a proper text editor:
* **Links are real text now**: click a link or button label to place the
cursor and type, double-click to select a word, and drag to select across
it. The link editor opens alongside without stealing your keyboard, and it
now includes a Text field so you can change a button's label and URL in
one place.
* **Undo and redo work reliably**: one Cmd/Ctrl+Z undoes your last edit and
keeps the cursor where you were, redo brings it back, and saving after an
undo saves what you see.
* **Cmd/Ctrl+K adds a link** using the same link editor as the rest of the
app.
* **Forward Delete respects your layout**: deleting at the end of a section
removes spacers or joins the next text section instead of breaking the
email's structure.
* **The view follows your cursor** when typing or pressing Enter near the
bottom of a long email.
* **Spell check is on** while writing, and the invisible characters some
editors leave behind no longer end up in sent emails.
### A More Fluid Email Editor
A batch of editing and drag-and-drop refinements that make composing emails
feel like a modern document editor:
* **Enter after a heading** starts a new paragraph below it (press Enter
mid-heading to split it), so you can type a title and keep writing.
* **Backspace works between blocks**: it deletes an empty block, and at the
very start of a block it joins the text into the previous one with the
cursor at the junction.
* **Drag and drop is precise**: dragged blocks track your cursor exactly,
drops land above or below a block depending on which half you release over
(with the insertion line showing exactly where), a new drop zone below the
last block lets you drop content at the end of the email, and dragging into
or out of columns shows the same insertion line.
* **Undo keeps your place**: after Cmd/Ctrl+Z the cursor returns to where you
were typing, so you can undo and keep writing without reaching for the
mouse.
* **Arrow keys cross blocks**: Left/Right at the edge of a block move into
the neighboring one, and Escape steps out of text editing to the selected
block, then clears the selection.
* **Slash commands clean up after themselves** - filtering the menu (like
`/div`) no longer leaves the typed query behind in the email - and the
formatting toolbar now waits until you finish selecting text instead of
popping in mid-selection.
### Dark Mode and Blocked-Images Preview
The editor's Preview tab can now simulate the two most common ways an email
breaks after sending. The dark mode toggle recolors your email the way Gmail
and Apple Mail force dark mode - light backgrounds go dark, dark text goes
light, and saturated brand colors stay put - so invisible text and
light-background logos show up before your subscribers see them. The
blocked-images toggle renders the email the way Outlook and corporate inboxes
show it before images load, so you can check that your alt text carries the
message.
### Smarter Pre-Send Checks
The deliverability checker now also catches practical mistakes, not just spam
signals: buttons and CTAs with no link or a placeholder link ("#", a bare
"https\://"), images missing alt text, button text with unreadable contrast,
buttons too small to tap on mobile, and emails whose HTML exceeds Gmail's
102KB clipping limit (which hides the rest of the message - including the
unsubscribe link - behind "View entire message").
### Sequence Editor: Undo, Simulation, and More
The sequence editor got a major usability upgrade:
* **Undo and redo.** Every canvas edit - adding, editing, deleting, and
reordering steps - can be undone with Cmd+Z and redone with Cmd+Shift+Z,
including accidental "Discard changes" clicks.
* **Path simulation.** Pick any subscriber and see exactly which steps they
would take through the sequence, evaluated with the same condition logic
the send path uses. The canvas highlights the path and explains each
condition and branch decision. Nothing is sent or enrolled.
* **Funnel view.** Toggle the new funnel mode (F) on an active sequence to
see where it leaks. Connections are only annotated where subscribers were
actually lost (hover for the breakdown of failed, stopped, or finished),
branch splits show their traffic share, and each email shows its open-rate
change versus the previous one - the usual drop-off signal in a linear
sequence.
* **Duplicate step.** Any action or delay step can be duplicated in place
from its editor. Duplicating an email step also clones the email, so the
copy is independently editable after you save the sequence.
* **Collapsible branches.** Wide branch sections can be collapsed into a
compact summary card showing how many steps are hidden inside.
* **Keyboard navigation.** Arrow keys walk the canvas, Enter opens the
focused email step, Delete removes it, and Cmd+F opens a step finder that
jumps to any step by name or subject.
* **Sort sequences by results.** Sequence lists can now be sorted by goal
conversions and attributed revenue, alongside date, opens, clicks, and CTR.
[View documentation](/concepts/sequences)
### Company Branding for AI-Generated Emails
Emails generated through the API, MCP server, and CLI now match drafts created
in the dashboard. Generated marketing emails include the company's logo and
footer by default, transactional emails use a footer without an unsubscribe
link, and campaigns and templates created through the API inherit the company
font. API and MCP callers can set `applyBranding: false` when they need only the
raw generated content blocks.
[View documentation](/api-reference/generate/email)
### Continue in Your Agent from the AI Sidebars
The AI assistant sidebars in the sequence builder and the email editor now
have an **Open in** menu next to the message box. Draft your request, then
copy it as an agent-ready prompt or open it directly in ChatGPT, Claude, or
the Cursor desktop app.
The prompt includes your company and sequence or campaign identifiers, so an
agent connected through the Sequenzy MCP server can pick up exactly where you
left off. The menu also links straight to the AI Agent Setup wizard if you
have not connected an agent yet.
[View documentation](/concepts/mcp)
### Full Recipient List on Multi-Recipient Transactional Sends
Transactional emails sent to multiple `to` addresses (or with cc/bcc) now
store the complete recipient list on the send record. The sent-email detail
page shows every recipient - including cc and bcc - instead of only the first
To address, and the email-sends API returns the list in a new
`additionalRecipients` field.
[View documentation](/api-reference/email-sends/get)
### Nested Repeat Blocks
Repeat blocks in the email editor can now be nested, with the inner repeat
drawing from an array inside each parent item - point its source at the
parent's item alias, like `item.lineItems`, instead of a separate top-level
array. The editor suggests these parent-scoped sources when a repeat block
sits inside another one, previews render real nested rows (including the
Preview tab, test emails, and the transactional API code examples), and
merge-tag suggestions inside the inner template pick up the nested item's
fields. Works in campaigns, sequences, and transactional templates.
[View documentation](/concepts/transactional-emails#nested-repeats)
### Product Feedback from the API, CLI, and MCP Server
You (or your AI agent) can now send product feedback to the Sequenzy team
from wherever you work: `POST /api/v1/feedback`, `sequenzy feedback "..."` in
the CLI, or the `submit_feedback` MCP tool. AI agents connected through the
MCP server are instructed to report a gap whenever you asked for something
the tools do not support yet - so the workflows you actually need reach us
without you filing anything. Feedback lands directly with the team and is
never stored in your account data.
[View documentation](/api-reference/feedback/submit)
### Chargebee Integration
Connect your Chargebee site and turn billing events into email automations:
* **One-time setup**: enter your site name, an API key, and webhook basic auth
credentials - Sequenzy shows you the exact webhook URL to paste into
Chargebee
* **Full historical sync**: customers, subscriptions, and paid invoices import
automatically on connect, with MRR and LTV calculated for every subscriber
* **Real-time billing triggers**: payments, failed payments, refunds, trial
starts, trial-ending reminders, trial conversions, cancellations, pauses,
resumes, and reactivations all map to built-in `saas.*` events for
automations
* **Automatic tags**: `customer`, `trial`, `cancelled`, `churned`,
`saas.monthly`, and `saas.yearly` stay current as subscription statuses
change
* **Duplicate-safe**: Chargebee webhook retries and duplicate deliveries never
double-count revenue, and a manual **Sync Revenue** action reconciles
anytime
* Supports both Product Catalog 1.0 and 2.0 sites, with non-USD currencies
converted automatically
[View documentation](/integrations/chargebee)
### Shopify SMS Consent Sync
Phone numbers and SMS marketing consent collected by your Shopify store now
flow into Sequenzy automatically. The initial customer sync imports each
customer's phone and SMS opt-in state (consent source `shopify`, with
Shopify's own consent timestamp), and customer webhooks apply opt-ins and
opt-outs as they happen - so a checkout opt-in on your store is immediately
usable by Send SMS steps in your sequences. The sync is TCPA-safe: consent is
only granted on an explicit Shopify opt-in, never inferred from a phone
number. Requires approved phone field access for protected customer data on
your store; without it, customer sync simply skips phone and consent.
[View documentation](/concepts/sms#shopify-sms-consent-sync)
### One-Off SMS from the Subscriber Page
Text a single contact without building a sequence. When a subscriber is
opted in to SMS marketing, their profile page now shows a **Send SMS**
button next to **Send email**. It opens the familiar SMS composer - merge
tags, emoji, images, AI assist - shows the estimated credit cost for the
contact's country before you send, and warns if your credit balance is too
low. One-off messages respect all the usual consent gates and quiet hours.
[View documentation](/concepts/sms)
### Inline Emoji Search in the Email and SMS Editors
Type `:` at the start of a word in any text block of the email editor, or in
the SMS composer, to open an inline emoji searcher right at your cursor.
Keep typing to filter by shortcode (`:tada`, `:fire`, `:+1`), move through
the results with the arrow keys, and press Enter to insert - no need to
reach for the toolbar picker. A bare `:` shows the most frequently used
emoji, so a couple of keystrokes is usually all it takes.
In the SMS composer, the searcher also reminds you when inserting an emoji
will switch a standard GSM-7 message to Unicode segments (70 characters per
segment instead of 160), so the cost change is never a surprise.
### Sequence Builder: Components Palette and Organized Step Menu
Building sequences is faster and easier to scan:
* **Floating components palette**: a new collapsible panel on the left of the
sequence canvas lists every step type. Click a component to add it at the
end of your flow, or drag it onto the canvas - every insertion point
between steps expands into a labeled drop zone while you drag, and the one
under your cursor shows exactly what will be inserted
* **Organized "Add a step" menu**: step types are now grouped into Messages,
Timing, Logic, and Actions sections in a wider two-column layout everywhere
you add a step, so the right step is easier to find without scrolling
### SMS Everywhere: AI Assistant, API, CLI, and MCP
SMS is now a first-class citizen across every Sequenzy surface, not just the
sequence builder:
* **AI assistant adds SMS steps natively**: ask the sequence assistant to
"add a shipping confirmation text" and it proposes a real Send SMS step with
drafted copy - no more webhook workarounds. SMS additions always require
your explicit approval before they apply
* **AI SMS copywriting**: the new `POST /api/v1/generate/sms` endpoint (and
`sequenzy generate sms` in the CLI, `generate_sms` in MCP) drafts on-brand
message variants with live encoding and segment counts
* **SMS steps via API**: create sequences with SMS steps
(`type: "sms"` with plain-text `text`) in explicit steps, branch paths, and
step insertion - so agents and migrations can build SMS journeys end to end
* **SMS readiness check**: `GET /api/v1/sms/settings` (CLI:
`sequenzy sms settings`, MCP: `get_sms_settings`) reports add-on status,
credit balance, numbers, and whether SMS steps will actually send
* **Edit SMS steps programmatically**: update an existing SMS step's text,
label, or ineligible-contact behavior via `smsSteps` in
`PUT /api/v1/sequences/{id}` (MCP: `update_sequence.smsSteps`, CLI:
`sequenzy sequences update --sms-steps-json`)
* **Test sends from anywhere**: `POST /api/v1/sms/test` (CLI:
`sequenzy sms send-test`, MCP: `send_test_sms`) sends a real test message -
credit-charged, quiet-hours exempt, capped at 5 per hour
* **SMS webhook events**: outbound webhooks now emit `sms.sent`,
`sms.delivered`, `sms.failed`, and `sms.opted_out` (included in the default
event set for new webhooks), so external systems can track SMS delivery and
opt-outs in real time
* Compliance is automatic: Sequenzy adds your brand prefix to every message
and the opt-out footer to the first message, so generated copy never needs
boilerplate
[View documentation](/concepts/sms)
### BCC Copies for Sequences
Sequences can now blind-copy your team on every email they send:
* Set one or more **BCC addresses** in the sequence settings modal - for
example your customer support inbox, so the team sees exactly what each
subscriber receives (separate multiple addresses with commas, up to 10)
* Copies are sent as true BCCs, so subscribers never see the extra recipients
* Applies to every email step in the sequence, including A/B test variants
* Leave the field empty to turn it off
* Also available via the API (`bccEmails` on `PUT /api/v1/sequences/{id}`), the
CLI (`sequenzy sequences update --bcc-emails`), and the MCP `update_sequence`
tool
[View documentation](/concepts/sequences#bcc-copies)
### Best Emails on the Metrics Dashboard
The metrics page now shows your top performing emails, so you can see at a
glance which campaigns and sequence emails actually drive results:
* **Best emails leaderboard**: the top 3 emails for the selected period,
covering both one-off campaigns and individual sequence emails (like each
step of your onboarding flow)
* **Sort by what matters**: rank by attributed revenue, unique opens, or open
rate - revenue is the default whenever at least one email has attributed
revenue
* **Jump straight to the source**: each entry links to the campaign or
sequence behind it
* **Drill into the numbers**: click an entry's opens, open rate, or revenue to
see exactly which subscribers opened the email or made an attributed
purchase
### Finish Setup, Earn 500 Bonus Emails
Completing the getting-started checklist now earns you 500 bonus email
credits, added to your account automatically:
* The checklist has a new third step: **Generate an API key** - connect the
API, CLI, or your AI agent alongside creating your first campaign and adding
subscribers
* Finish all three steps and 500 bonus emails land on your account (one time
per account). Credits are spent before your plan allowance
* Any API key counts - one created from the setup flow, the settings page, or
a CLI/MCP login
### Meta Audience Syncs Handle Lost Connections Gracefully
Meta audience syncs now recover from connection problems instead of failing silently:
* **Self-healing audiences**: if the Meta audience behind a sync disappears (deleted in Ads Manager, or replaced by a reconnect), the next run recreates it automatically and continues syncing
* **Automatic pause on revoked connections**: when Meta stops recognizing the connection (password change, revoked permission), the sync is paused and marked **Disconnected** instead of retrying forever
* **Guided reconnect**: the audience sync dialog shows exactly what happened with a one-click reconnect button - reconnect, resume the sync, and it picks up on the next run
The `disconnected` status is also visible via the [audience syncs API](/api-reference/audience-syncs/list), CLI, and MCP. [View documentation](/integrations/meta-ads)
### International SMS With Cost-Weighted Credits
The SMS add-on now reaches 20+ countries beyond the US and Canada, including
the UK, Ireland, most of Western and Northern Europe, Poland, Czechia,
Ukraine, Australia, and New Zealand:
* **Cost-weighted credits**: US/CA segments stay at 1 credit; international
segments use a per-country multiplier that reflects real carrier cost, so
you're never surprised by destination pricing
* **Pricing calculator**: pick a destination country and a monthly budget in
`Settings -> SMS` to see how many messages it buys and the effective
per-SMS rate, plus a full "View all country rates" table
* **Country-aware quiet hours**: the 11am-8pm send window is now evaluated in
the recipient country's timezone, not just Eastern Time
* **Clear eligibility**: subscriber profiles show each contact's phone
country, the credit multiplier that applies, and exactly why a contact
can't receive SMS; unsupported countries are skipped, never silently billed
* SMS now requires a **paid plan** (from \$19/mo)
* **Add it at upgrade**: the plan upgrade dialog offers the SMS add-on under
Add-ons with a volume slider - pick a monthly credit bundle (1k for \$16/mo
up to 75k) and buy it together with your plan. It stays a monthly charge
even alongside an annual plan
* **Segment and branch on SMS reachability**: new `Phone Number` and
`SMS Status` segment filters, plus **Has phone number** and **Subscribed to
SMS** conditions in if/else and multi-branch sequence steps
* **Skip or exit for unreachable contacts**: each Send SMS step can either
skip contacts who can't receive SMS (default) or exit the sequence for them
* **At-a-glance consent in the subscriber list**: the Status column shows a
green phone icon when a contact has a number and a red one when they opted
out of SMS
[View documentation](/concepts/sms)
### Shipment Tracking, Browse Abandonment, and Price Drop Events for Shopify
The Shopify integration now covers the full post-purchase and browse journey:
* **Shipment events**: `ecommerce.order_shipped`, `ecommerce.order_out_for_delivery`, `ecommerce.order_delivered`, and `ecommerce.delivery_failed` fire per shipment with tracking number, tracking URL, and carrier - build shipping confirmations with tracking links, and time review requests off the actual delivery instead of the order date. Reconnect your store once to grant the new `read_fulfillments` scope.
* **Browse abandonment**: when a known subscriber views a product and doesn't buy, start a checkout, or add it to cart within the browse window (default 2 hours), `ecommerce.browse_abandoned` fires with the viewed product - at most once per subscriber per day
* **Price drop alerts**: when a product's price drops by 5% or more, `ecommerce.price_drop` fires for everyone who viewed or carted the product in the last 30 days, with old price, new price, and percent off. If no sequence handles the event, a default price-drop email goes out automatically (active subscribers only) - build your own sequence on the trigger to replace it
* **Accurate checkout recovery**: `ecommerce.checkout_started` now also fires from checkout updates the moment the buyer's email is known (once per checkout), and carries `abandonedCheckoutUrl` plus the final cart contents
* **Honest revenue on refunds and cancellations**: refunded and cancelled orders now subtract from subscriber revenue attributes (`totalSpent`, `ltv`, `aov`, `ordersCount`) and net out attributed campaign/sequence revenue
* **Live catalog**: product create/update/delete webhooks keep synced products, prices, and images fresh between full syncs
* **Richer browse tracking**: the storefront pixel now also captures collection views (`ecommerce.collection_viewed`) and searches (`ecommerce.search_submitted`)
* **Simple controls everywhere**: tune or disable browse abandonment and price drop from the Shopify settings dialog in the dashboard, `sequenzy shopify settings` in the CLI, the `get/update_shopify_automation_settings` MCP tools, or `GET/PUT /api/v1/shopify/automation-settings`
* **One-click sequence templates**: Shipping Confirmation, Delivered Review Request, Browse Abandonment, and Price Drop Alert templates, each pre-wired to the right trigger. Browse-abandonment and price-drop sequences automatically stop when the shopper buys the product
All new events are available as sequence triggers, sync rule triggers, and segment activity. [View documentation](/integrations/shopify)
### Evidence-Based Domain Verification
Domain verification now runs on a per-record evidence model, making statuses
trustworthy and actionable.
* **A new "Misconfigured" status.** When a DNS record exists but has the wrong
value (a conflicting MX from an old provider, a mistyped SPF), the domain now
shows "Misconfigured" with the exact record to fix - instead of a generic
"Failed". The API returns the new status as well.
* **No false alarms, structurally.** A domain status only changes after
repeated, confirmed observations spread over a time window. Lookup timeouts
and nameserver hiccups can never demote a domain; genuinely deleted records
are still caught within minutes of confirmation.
* **"Rechecking DNS records" hint.** If a check sees an inconsistent answer,
the domain stays verified and sending continues while Sequenzy re-confirms
over the next few minutes - and the dashboard says so.
* **Smarter setup window.** While you are actively adding records, the domain
stays "Pending" with live per-record feedback. Waiting on the email provider
never counts against your setup time.
* **Internal transition logs.** Every status transition is written to the
audit trail and logged in Telegram with the DNS/provider evidence that
triggered it.
* **Tracking domains** now follow the same verification model, including
internal status-change logs.
### Recurring Campaigns
Campaigns can now repeat on a schedule. Pick **Every week** or **Every month**
when scheduling a campaign and Sequenzy re-sends it automatically:
* The audience is re-evaluated at every run - new subscribers who match the
list or segment are included, unsubscribed or removed ones are skipped
* Each run appears as its own campaign with its own stats, named after the
template with the run date
* The email content is snapshotted per run, so you can keep editing the
template between sends without rewriting past run history
* Cancel the recurring campaign at any time to stop the series
Combined with product rotation (below), this powers set-and-forget monthly
digests - top picks for an interest segment - that never repeat products a
subscriber has already seen. [View documentation](/concepts/campaigns)
### Product Rotation: Don't Show The Same Products Every Send
Product lists in emails now rotate their content between sends, so each
recipient only sees products that are new to them:
* Recommended product lists rotate automatically - nothing to configure
* Catalog lists can opt in with the **Don't repeat products** toggle in the
block's settings
* Purchased products stay excluded, and when a recipient has seen everything,
the oldest-seen products come back so the list never renders empty
### Tag Buyers By What They Bought
Sync rules on commerce events can now match the purchased products. Add a
**Product match** condition to an Order Placed rule and tag buyers by product
tag, collection, or product type - for example, tag anyone who buys a product
tagged "Vinyl" as a `vinyl-collector`, then target that audience with its own
campaigns. [View documentation](/concepts/sync-rules)
Sync rules are also manageable programmatically now: `GET`/`PUT
/api/v1/sync-rules` on the API, `sequenzy sync-rules` on the CLI, and
`get_sync_rules` / `update_sync_rules` MCP tools. Recurring campaigns can be
scheduled programmatically too, via `recurringInterval` on the campaign
schedule endpoint, `--repeat` on the CLI, and `schedule_campaign` over MCP.
### Cleaner Block Settings In The Email Editor
Every block settings panel in the email editor has been redesigned around one
consistent structure, so the same controls always look and behave the same
way:
* Settings are now grouped into titled sections (Content, Layout, Style,
Visibility) with clear dividers, ordered by how often you need them
* Related controls share a row - width sliders include their unit toggle,
corner radius pairs a value input with quick presets, and padding uses four
clearly named inputs (Top, Right, Bottom, Left)
* Optional settings like fixed image height or discount expiration reveal
their controls only when switched on
* Container styling (background, border, radius, padding) folds into a
collapsed "Block Style" section that shows a one-line summary of what you
customized, so untouched defaults no longer crowd the panel
* The countdown deadline is now a single date-and-time picker instead of two
separate fields
* The panel is wider, so two-column rows have room to breathe
### Product Images As AI References For Everyone
Generating an image in the email editor can already use one of your product
photos as a reference, so the result stays faithful to your actual product.
Previously this was limited to e-commerce workspaces - now any company with
synced products (Shopify, WooCommerce, Stripe, or the products API) can pick a
product image as the reference.
We also polished the flow:
* The product reference picker now shows a visual grid of product photos, so
you pick by image instead of by name
* Image block settings show a live preview of the current image, and a new
**Generate with AI** shortcut opens the image dialog straight on the AI tab
### Dynamic Product Lists From Your Store
Repeat blocks can now pull products straight from your synced store catalog -
no merge variables needed. The block settings open with one question, **What
to show**, and each answer is a single choice:
* **Recommended products** - picked per recipient from their browsing and
cart activity, then similar shoppers, then store bestsellers, then the
newest in-stock products so the list never renders empty. The settings
panel explains exactly how picking works, and a product never repeats
within a list or across lists in the same email - even when the same
product was synced twice under different ids
* **Store catalog** - your catalog, sorted by newest, price, or title, with
optional filters by tag, collection, vendor, product type, or price range,
resolved fresh at send time
* **Hand-picked products** - select exactly which products to show and in
what order, with prices, images, and stock kept in sync with your store
* **Campaign list** - a personalized list computed by your campaign's rules
Recommended and catalog lists can also be fine-tuned per block:
* **Skip already-purchased products** leaves out anything the recipient
bought in the last year - on by default for recommendations, opt-in for
catalog lists
* **Match the trigger event's product** limits the list to products related
to the product on the event that triggered the email, so a
browse-abandonment sequence can recommend items related to what the shopper
viewed. The relation is customizable: pick which attributes must overlap
(tags, collection, product type, or brand) and whether products must match
any or all of them
Product lists work everywhere emails send: campaigns, **sequences**, A/B
tests, and test emails. Filters apply per send, so an abandoned-cart sequence
can always show in-stock products from a specific collection.
The editor previews product lists with real products from your catalog, and
new **item templates** (card grid, spotlight, compact rows, minimal list) let
you restyle a repeated list in one click.
Shopify product syncs now also capture tags, vendors, product types, and
collections, which power the new filters. Re-sync your store to pick them up.
[View documentation](/guides/email-editor)
### SMS & MMS Add-on
You can now send text messages to your US and Canadian subscribers with the new
SMS add-on - \$16/month including 1,000 message credits, with extra credit packs
available whenever you need more.
Enable it in **Settings -> SMS** and Sequenzy provisions a dedicated toll-free
number for you automatically. A short verification wizard collects your
business details, and once carriers approve the number (typically 1-5 business
days) you're ready to send.
Add a **Send SMS** step to any sequence and write the message in a lightweight
composer built for texting: plain text plus up to two images, merge tags for
personalization, and a live counter that shows exactly how many segments - and
credits - each message costs as you type.
* **Separate SMS consent** - every subscriber has a phone field and an SMS
consent status independent of their email status. Set consent when importing
via CSV (with column mapping), through the API, or manually in the app.
Consent is never inferred from a phone number alone.
* **Compliance built in** - STOP and HELP keywords are handled automatically,
and quiet hours keep sends inside 11am-8pm ET (from 2pm on Sundays). Messages
triggered outside the window are delivered when it reopens, never dropped.
* **Click tracking** - links are shortened automatically and clicks feed into
your stats and revenue attribution, just like email.
* **Prepaid credits** - buy credits up front, get a low-balance email alert
before you run out, and top up in a click.
* **Replies land in your inbox** - when a subscriber texts back, the reply is
forwarded to your account email.
[View documentation](/concepts/sms)
### More Reliable Domain Verification
Domain verification is now far more resilient, so verified domains stop
flipping to "failed" because of temporary DNS hiccups.
* **No more false failures.** A verified domain is only marked failed after
several consecutive checks confirm the records are really gone. A DNS lookup
that times out or errors no longer counts against your domain, and we recheck
within minutes instead of hours whenever a check is inconclusive.
* **Delegated DNS zones now verify correctly.** If your sending subdomain is
hosted as its own DNS zone (for example, a separate zone for
`mail.yourdomain.com`), our checks now query the right nameservers. These
setups previously could fail verification even with correct records.
* **Sends are held, not lost.** If a domain is temporarily unverified, queued
emails are delayed and retried automatically for about 20 minutes instead of
failing immediately - enough to ride out a brief verification blip.
* **Flexible SPF records.** Your SPF record can include other providers
alongside `include:amazonses.com` (and use `-all`); verification no longer
requires an exact match.
* **Tracking domains work behind Cloudflare.** Custom tracking domains proxied
through Cloudflare (orange cloud) now verify correctly.
* **Internal verification alerts.** If a verified domain loses verification,
Sequenzy logs the transition internally with the record that needs
attention. The dashboard banner continues to show affected domains.
### API Key Permission Scopes
API keys can now be restricted to a specific set of permissions instead of
always having full workspace access. Every API request checks the key's
permissions and returns a clear 403 error naming any missing scope.
When creating a key - in the dashboard, through the API, the CLI
(`sequenzy api-keys create --preset ...`), or the `create_api_key` MCP tool -
you can pick a **preset** (Full access, Read-only, Safer agent access,
AI drafting, Data ingest with or without automations, Transactional sender,
or Marketing sender) or select **custom permissions** scope by scope.
A few things worth knowing:
* **Existing keys are unchanged** and keep full access.
* **AI agent logins now default to Safer agent access.** When you approve a
CLI or MCP connection, the consent screen lets you choose the key's
permissions, and the default can inspect data and draft content but cannot
send live emails, delete records, manage the team, or create API keys.
Pick Full access on the consent screen if your agent needs to send.
* **Live delivery is opt-in.** Sending requires explicit permissions such as
`campaigns:send`, `transactional:send`, `sequences:activate`, or
`automations:trigger`. Keys without `automations:trigger` can still sync
subscribers, events, and orders, but those writes will not start or continue
automations, and creating subscribers that would queue a double opt-in
email is rejected.
* **SMTP checks permissions too.** Authenticating to the Sequenzy SMTP relay
requires a company key with the `transactional:send` permission.
[View documentation](/authentication)
### Code In The Email Editor
You can now show code in your emails, both inline snippets and full multiline
blocks, so things like coupon codes, variable names, API keys, and commands
stand out clearly.
For **inline code**, select any text and use the new **Code** button in the
formatting toolbar, or wrap a word in single backticks (`` `SAVE10` ``).
For longer snippets, add a dedicated **Code block** from the `/` insert menu (or
the add-block button). It is a standalone block you can drag and reorder like
any other, with a multiline editor that preserves your indentation and line
breaks exactly.
Code blocks support **color themes** - Light, Dark, Midnight, Terminal, and
Solarized. Open the block's settings panel to switch themes. Themes use plain
inline colors (no syntax highlighting), so they render reliably across email
clients, and the block looks identical in the editor and the delivered email.
[View documentation](/guides/email-editor)
### Resend Campaigns To Non-Openers
After a campaign finishes sending, you can now resend it to everyone in the
same audience who didn't open it - a simple way to recover opens without
rebuilding the audience.
On a sent campaign, use the new **Send to non-openers** button. It shows an
estimate of how many people haven't opened yet, then creates a draft that
reuses the original audience with a "didn't open this campaign" rule added. The
draft isn't sent automatically, so you can review it and tweak the subject line
before scheduling or sending.
* Available 6 hours after the campaign finishes sending, so opens have time to
register.
* Works for any audience - all subscribers, lists, saved segments, or filtered
audiences. Manual exclusions are preserved.
* Also available via the API, CLI (`sequenzy campaigns resend-to-non-openers`),
and MCP (`resend_campaign_to_non_openers`).
[View documentation](/api-reference/campaigns/resend-to-non-openers)
### Conditional Blocks Can Branch On Request And Event Variables
Conditional (if/else) blocks in the email editor can now branch on a custom
variable passed in your transactional send `variables` or an automation `event`
payload, not just stored subscriber fields.
Add a condition, choose the new **Custom variable** field, and type any
`{{merge tag}}` path - including nested paths like `order.total` or
`event.plan`. Compare with equals, contains, numeric operators (`>=`, `<=`,
`>`, `<`), or use "is empty" / "is not empty" to check whether the variable was
provided.
For example, sending with `"variables": { "plan": "pro" }` renders the IF branch
of a `plan equals pro` condition and the OTHERWISE branch for everyone else - so
a single template can adapt its content per request.
[View documentation](/concepts/transactional-emails)
### Raw Campaign And Sequence Event Logs
You can now inspect the raw event stream behind campaign and sequence metrics. Use it when you need to audit exactly which subscribers were delivered, opened, clicked, bounced, complained, unsubscribed, or hit delivery delays.
Start with deliveries to verify recipients:
```bash theme={null}
curl "https://api.sequenzy.com/api/v1/metrics/campaigns/camp_abc123/events?limit=100" \
-H "Authorization: Bearer YOUR_API_KEY"
```
Expand the stream when you need engagement or deliverability details:
```bash theme={null}
curl "https://api.sequenzy.com/api/v1/metrics/sequences/seq_abc123/events?eventTypes=delivery,open,click,bounce&period=30d" \
-H "Authorization: Bearer YOUR_API_KEY"
```
The same workflow is available from the CLI:
```bash theme={null}
sequenzy events --campaign camp_abc123 --limit 100
sequenzy events --sequence seq_abc123 --event-types delivery,open,click --period 30d --json
```
Agents can use the new MCP tools `list_campaign_events` and `list_sequence_events`. By default, engagement events exclude detected scanner and preview activity; pass `includeMachineEngagement=true` or `--include-bots` when you need the unfiltered raw stream.
[View campaign events documentation](/api-reference/analytics/campaign-events)
[View sequence events documentation](/api-reference/analytics/sequence-events)
### Wait Until A Date In Sequences
Sequence Delay steps can now wait until a date pulled from the triggering event, not just a fixed number of days or hours.
Turn on the **Wait until a date** switch in a Delay step, then point it at a property in the event payload (for example `renews_at` or `booking.startsAt`). The subscriber resumes exactly when that date arrives.
* The date can be an ISO date string or a Unix timestamp
* Add an optional offset to resume before or after the date, like **1 day before** a renewal or **2 hours after** a booking
* Choose what happens if the date is missing or invalid: continue to the next step, or exit the sequence
* If the resolved date is already in the past, the step continues immediately
This makes it easy to build renewal reminders, appointment follow-ups, and trial-expiry nudges that line up with each subscriber's own dates.
[View documentation](/concepts/sequences)
### Agent Auth Discovery And Current Limits
Sequenzy now publishes `auth.md` and OAuth discovery metadata so agents can find the supported user-approved registration flow for MCP/API access.
This does not mean Sequenzy is fully agent-friendly yet. MCP, CLI, and auth discovery cover many common workflows, but some setup, billing, destructive account actions, advanced configuration, and final send decisions may still require dashboard use or explicit human review.
[View MCP documentation](/concepts/mcp)
### Inbound Reply Webhook Events
Outbound webhooks can now subscribe to `email.replied`, so your app can react as soon as a subscriber replies to a tracked email.
The event fires after Sequenzy stores the inbound reply and inbox conversation message. Its payload includes the reply ID, conversation ID, original email send context, subscriber or external ID when available, sender details, body text, HTML body, stripped reply text, attachment metadata, and received timestamp. Attachment bodies are not sent in webhook payloads.
You can select `email.replied` from the dashboard webhook event picker, pass it through the public webhooks API, use it with the CLI, or configure it through MCP tools. It is opt-in and not part of the default webhook event set.
[View outbound webhook documentation](/integrations/outbound-webhooks)
[View reply tracking documentation](/concepts/reply-tracking)
### 20% Off Your First Year For New Accounts
New workspaces now get 20% off the first year of any annual plan when they upgrade within their first 5 days. Pick Yearly at checkout during the offer window and the discount is applied automatically - there is no code to enter, and the plan renews at the standard annual price after year one.
This replaces the previous early-bird "+5% extra emails" bonus. Accounts that already claimed the email bonus keep it for the full 6 months; the new discount applies to upgrades going forward.
We also added a one-time upgrade nudge that appears right after you activate your first sequence or send your first campaign. While the offer is live it highlights the 20% discount with a countdown, so it is easy to lock in annual pricing at the moment you are getting value. The in-app offer banner and pricing screen show the discounted first-year price up front, and the Upgrade button in the sidebar lights up with a live countdown while the offer is running so you never lose track of it.
### Webflow Marketplace Install Onboarding
The Webflow Marketplace install page now gives signed-out visitors a guided
Sequenzy onboarding step before OAuth. Existing users can sign in and continue,
new users can create an account, and both paths keep the redirect back to the
Webflow install flow so authorization can continue without losing context.
The sign-in and sign-up screens also show a Webflow-specific install notice
when they were opened from the marketplace flow, making it clear that the next
step is authorizing Webflow form capture.
[View documentation](/integrations/webflow)
### Click Metrics To Chart Them
The trends chart on the Metrics dashboard is now interactive. Click any Overview card - Emails sent, Deliverability, Open rate, Click rate, Unsub rate, Reply rate, or Revenue - to add or remove its line from the chart, so you can compare several metrics over time at once. Emails sent and Open rate are shown by default.
Each card and its line share a color, the legend shows the total for every selected metric, and hovering any point lists the value and rate for each line on that day. Revenue is plotted on its own currency axis so it stays readable next to email volumes.
### Backfill Existing Shopify App Merchants
Connecting a Shopify app now has a way to bring in the merchants you already have. Shopify never replays past installs, so the live webhooks only cover changes going forward - the new bulk identify endpoint lets your backend push every current merchant in one call.
Each merchant is created or updated as a subscriber, gets its Shopify app attributes plus `mrr` and `ltv`, and is marked installed. You can carry the plan price and let Sequenzy derive MRR (yearly prices are normalized to monthly), or pass `mrr` and `ltv` directly for exact figures. Send up to 1000 merchants per request. The backfill never triggers automations, so seeding existing merchants will not email them.
[View documentation](/integrations/shopify-app)
### Shared Domain Warning Before Large Sends
Sending a big campaign from a shared sending domain (one of the `sequenzymail.com` addresses) now prompts a heads-up before it goes out. When a campaign to more than 500 subscribers is still on a shared domain, pressing send opens a short reminder that shared domains often land in spam, with a 10-second pause before "Send anyway" unlocks and a one-click path to connect your own domain for better inbox placement.
It only appears when it matters - smaller sends and campaigns already on a verified custom domain are unaffected - and you can tick **Don't show this again** to dismiss it for good.
[Connect your domain](/guides/domain-verification)
### SMTP Settings In The Dashboard
Set up SMTP sending without leaving your workspace. **Settings → SMTP** now shows your full connection details - host, port, username, and encryption - each with one-click copy, plus a ready-to-paste Nodemailer example.
You can generate the API key that doubles as your SMTP password right from the same screen. Click **Generate API key** and it is created, copied to your clipboard, and shown once so you can store it safely - no more hopping to the API Keys page mid-setup. Generating a key requires an admin role; everyone else sees the connection settings and a pointer to request one.
[Send with SMTP](/send-email/smtp)
### Unsubscribe Page Now Follows Your Branding
The unsubscribe and email preferences page no longer shows the Sequenzy website header, footer, or live chat widget. Your subscribers now see a clean, standalone page with your company logo, name, and brand color applied to the controls - the save button and subscription toggles match your branding instead of Sequenzy's.
For free-tier workspaces, the page shows the same "Powered by Sequenzy" pill that appears in emails. Paid plans stay fully white-label.
### Saved Signup Forms
Signup forms are now saved in your dashboard instead of living only in copied embed code. Create as many forms as you need - one per page, campaign, or audience - and manage them from **Audience → Forms**.
**What's included:**
* Each form gets its own name and submission endpoint, with submission counts shown next to every saved form
* Audience targeting (lists, tags) and success behavior (message or redirect) are stored server-side, so editing them in the dashboard updates forms already deployed on your website - no re-embedding needed
* Edit, embed, or delete any saved form from the Forms screen
* Embed forms with a one-line JavaScript snippet or full HTML
* Plain HTML embeds set to show a success message now get a hosted confirmation page instead of raw JSON
* Free workspaces show a small "Powered by Sequenzy" pill under embedded forms and on the hosted confirmation page. Upgrading removes it - regenerate the embed code after upgrading to drop it from forms already on your site
* Existing deployed embeds keep working unchanged on the previous company-level endpoint
[View documentation](/widgets/signup-form)
### Meta Custom Audience Sync
Push any segment to a Meta custom audience and keep it in sync automatically. Run Facebook and Instagram ads that target - or exclude - exactly the same people as your email campaigns, without exporting CSVs.
**What's included:**
* Connect your Meta account in Settings → Integrations under the new Ads & Audiences section
* Map any segment to a custom audience in one of your Meta ad accounts, with hourly, daily, or weekly refresh
* One-click ready-made segments built for paid social: **Zero LTV**, **No purchase in 1 year**, **Recent buyers**, **High spenders**, **Non-buyers**, **Engaged**, and more - picked to match your store or SaaS setup
* Manual "Sync now", pause/resume, and per-sync status with last-synced counts
* Emails are SHA-256 hashed before reaching Meta; only active subscribers are uploaded
* Full agent-surface support: manage syncs via the [API](/api-reference/audience-syncs/list), the CLI (`sequenzy audience-syncs`), and MCP tools (`create_audience_sync` and friends)
Audiences are add-only (Meta doesn't support removals through this integration), and Meta requires 100+ matched people before an audience is usable for delivery.
[View documentation](/integrations/meta-ads)
### Campaign Revenue Attribution for E-Commerce Orders
See how much money a send made. Commerce orders (Shopify, WooCommerce, and the Commerce API) now feed the built-in revenue goal, and attributed conversions and revenue show up everywhere campaign and sequence stats do.
**What's included:**
* Every `ecommerce.order_placed` event is attributed to the most recent email open or click within 24 hours (last-touch), using the order total as revenue. Repeat purchases count - unlike SaaS renewals, every placed order is a deliberate buy
* Campaign and sequence stats now include `conversions` and `revenueCents` in the [metrics API](/api-reference/analytics/campaign-metrics), the CLI (`sequenzy stats --campaign`), and the `get_campaign_stats` / `get_sequence_stats` MCP tools
* The dashboard's existing revenue attribution views (campaign list and detail) pick up commerce revenue automatically
* No setup needed - this extends the default revenue goal that already tracks `saas.purchase`. [View documentation](/concepts/goals)
### Segment by Purchased Product
Build segments and target campaigns by the e-commerce products a subscriber actually bought.
**What's included:**
* New "Purchased Product" segment filter with bought / didn't buy / orders at least / orders less than operators
* Works across all commerce providers - Shopify, WooCommerce, and Commerce API orders - by matching order line items, including all your historical orders
* Available in the dashboard segment editor (with a product picker), the segments API, the CLI (`sequenzy segments create --commerce-product shopify:42`), and the `create_segment` / `update_segment` MCP tools. Filter values are provider-scoped (`provider:productId`) so the same product ID on two providers never collides
* Composable with every other filter, including nested AND/OR groups
### Landing Page Actions For API, CLI, And MCP
Landing pages can now be managed from Sequenzy's public API, CLI, and MCP tools, so agents and scripts can handle the same page lifecycle that exists in the dashboard.
**What's included:**
* Create, list, inspect, update, publish, unpublish, and delete landing pages through `/api/v1/landing-pages`
* Connect, update, and verify landing page custom domains from API, CLI, and MCP
* New CLI commands under `sequenzy landing-pages`
* New MCP tools such as `create_landing_page`, `publish_landing_page`, and `connect_landing_page_domain`
* Dashboard **AI Agent Setup** copy now points users toward landing page workflows
[View landing pages documentation](/concepts/landing-pages)
[View MCP documentation](/concepts/mcp)
### Fixes for Shopify Product Currency and Description Formatting
Synced Shopify products now always use your store's own currency. Previously, stores with multiple market currencies enabled could see prices labeled with the wrong currency (often AED) in product pickers and product blocks.
Product prices now match your storefront's default variant instead of the cheapest variant, so the price shown in emails is the same one customers see on the product page.
Product descriptions imported from Shopify and WooCommerce are now converted to clean plain text. Previously, descriptions could show raw HTML tags (like `` and ``) in the email editor and in sent emails. Existing product blocks with HTML in their descriptions are cleaned up automatically when rendered - no action needed.
Product blocks also gained a description length control: choose to show the full description or just the first 1-5 sentences. The full text stays saved on the block, so you can switch back anytime. The description field in block settings is now a proper multi-line editor as well.
Prices and currencies refresh on the next product sync. If a product block already shows the wrong currency, re-select the product after syncing to update it.
### Double Opt-In Now Covers Events, Webhooks, and Tags
Double opt-in previously applied only to contacts created through signup forms and the subscribers API. Contacts created by events - external app triggers like Tally or Cal.com, the events API, or tag operations - became active immediately and sequences sent right away.
With this change, every path that creates a brand-new contact respects the workspace double opt-in setting:
* New contacts created by events or tags are stored as pending and receive your confirmation email automatically
* Sequences triggered by the event or tag enroll the contact but wait at the trigger step - the first email only sends after the contact confirms
* Confirming resumes all parked sequences at once; enrollments that are never confirmed within the confirmation window are cancelled automatically
* Events and tags are still recorded while confirmation is pending, so segments and analytics stay accurate
* Contacts who unsubscribed earlier are never re-enrolled, and existing active contacts are unaffected
No setup changes are needed - if double opt-in is enabled, it now simply applies everywhere. [View documentation](/concepts/double-opt-in)
### Pick Products Directly in Trigger Filters
When a sequence trigger fires on a product-aware event - order placed, checkout started, replenishment due, back in stock, or a Stripe purchase - you can now pick one or more products from your catalog instead of typing raw IDs.
**What's included:**
* An "Only for products" picker on the trigger, shown for any event that carries a product. It works across all providers: Shopify, WooCommerce, Stripe, and products pushed via the Commerce API
* Select multiple products to start the sequence when the event includes any of them
* Searchable product list with images, provider, and product ID - and an escape hatch to enter a custom ID for products not yet synced
* Property filter rows on product ID fields (like `lineItems[].providerProductId`) now use the same picker for their value instead of a free-text input
* Order and cart events now suggest `lineItems[]` fields (product ID, SKU, title, variant, quantity, price) in the property path autocomplete
* New `one_of` property filter operator that matches when a property equals any entry of a list (up to 50 values) - available in the dashboard, [API](/api-reference/sequences/create), CLI, and MCP
* Picker selections are scoped to the product's platform - one platform per filter, with platform-qualified custom IDs - so a product ID from one store can never accidentally match an identically numbered product from another
* Shopify checkout and refund events and WooCommerce cart/checkout events now include the same normalized `lineItems` as order events, so product filters work consistently across providers (refund events list the refunded products)
The picker writes a standard property filter, so it stays fully compatible with filters created manually, via the API, or through MCP.
### Redesigned Settings Navigation
Company settings now use a grouped sidebar instead of a long row of tabs. All 16 sections are organized into five groups - General, Email & Sending, Data & Automation, Integrations & API, and Workspace - so every destination is visible at a glance and one click away.
Existing links to specific settings sections keep working, and the mobile section picker is grouped the same way.
### Agent-Surface Parity: Run Campaigns, Audience, Team, Inbox, and Webhooks From CLI, MCP, and API
The dashboard is no longer the only place to operate Sequenzy. You can now cancel or pause a sending campaign, manage your audience, invite teammates, triage replies, and manage outbound webhooks from the CLI, MCP tools, and the public API alike.
**What's included:**
* Cancel, pause, or resume a sending campaign - resume can spread the remaining delivery over up to 72 hours - and duplicate or delete campaigns
* Create campaign A/B tests with test percentage, duration, and winner criteria, then add or remove variants
* Manage lists, segments, and tags fully: update and delete them, and remove subscribers from a list in bulk
* Manually enroll up to 500 subscribers into a sequence, starting at any step
* List your team, invite teammates as admin or viewer, and cancel pending invitations
* List, read, and reply to inbox conversations, add internal notes, and open, close, or mark them read
* Create, update, test, and delete outbound webhooks, inspect deliveries, and replay them - the signing secret is shown once at creation. `DELETE /v1/webhooks/:id` now permanently deletes the endpoint and its delivery history (it previously only disabled it); use `PATCH` with `status: "disabled"` to keep an endpoint without deleting it
Destructive CLI commands ask for confirmation and accept `--yes` for scripts and agents.
[View CLI documentation](/concepts/cli)
[View MCP documentation](/concepts/mcp)
### Fixed: Segment Filters on Boolean Attributes
Segment and contact filters on boolean attributes (for example `isActive equals false`) now match subscribers correctly. Previously these filters always returned zero results.
Boolean values are now matched strictly: filtering on `true` or `false` matches boolean attribute values only, and filtering on `0` or `1` matches numeric attribute values only.
### Commerce API: Connect Any E-commerce Platform
You can now connect any e-commerce platform to Sequenzy - custom checkouts, CheckoutChamp, Sticky.io, headless storefronts, or your own backend - and get the same experience as the native Shopify and WooCommerce integrations.
**What's included:**
* Push your product catalog with `POST /api/v1/products` - products power email product blocks, replenishment reminders, and back-in-stock alerts
* Push orders with `POST /api/v1/orders` - one call upserts the customer, triggers `ecommerce.order_placed` (or cancelled/fulfilled/refunded), updates revenue attributes (`ltv`, `totalSpent`, `ordersCount`, `aov`), and schedules replenishment
* Track started checkouts with `POST /api/v1/checkouts` to power abandoned checkout automations
* Register back-in-stock requests with `POST /api/v1/back-in-stock` - subscribers are notified automatically when a product upsert marks the item back in stock
* Safe retries everywhere: pushing the same order twice never double counts revenue
* Pass authoritative `customerTotals` from your platform when backfilling order history
* Manage the catalog without code: `sequenzy products upsert` / `sequenzy products delete` in the CLI (with one-shot deliverable upload via `--file`), and `upsert_products` / `delete_product` MCP tools (`attach_product_file` also accepts a local `filePath` when the MCP server runs locally)
[View documentation](/concepts/custom-commerce)
### Digital Product Delivery for Stripe Products
You can now sell digital products through any Stripe checkout and let Sequenzy deliver the file automatically after purchase.
**What's included:**
* Your Stripe product catalog now syncs into Settings → Products (alongside Shopify and WooCommerce products)
* Attach a deliverable file to any Stripe product - upload it to Sequenzy (PDF, ePub, ZIP, images, audio, video - up to 100MB) or link to an externally hosted file
* Purchases automatically enrich the `saas.purchase` event with `download.url` and `download.name`, so sequence emails can link straight to the file
* A new **Only for product** picker on purchase triggers starts a sequence only when a specific Stripe product is bought
* Product-scoped triggers are also available programmatically: pass `propertyFilters` to `POST /api/v1/sequences`, the `create_sequence` MCP tool, or `sequenzy sequences create --property-filters-json`
* The email editor suggests the download variables when building purchase sequences
* Works with Stripe payment links and Stripe Checkout - no checkout changes required, and buyers become subscribers automatically
* Full API support: list products, attach/remove delivery files, presigned file uploads, and catalog sync via `/api/v1/products`
* CLI support: `sequenzy products list`, `sequenzy products attach-file prod_abc --file ./guide.pdf`, `sequenzy products sync`
* MCP support: `list_products`, `attach_product_file`, `remove_product_file`, and `sync_products` tools
[View documentation](/concepts/digital-products)
### Hosted Landing Pages
You can now create hosted landing pages in Sequenzy and route signups directly into your subscriber lists, tags, and automations.
**What's included:**
* Build pages from templates for waitlists, lead magnets, launches, webinars, newsletters, demo requests, seasonal offers, agency leads, and feature announcements
* Edit sections, blocks, images, copy, desktop/mobile previews, SEO metadata, and page-level style settings in one workspace
* Add a native signup form with first name, last name, custom placeholders, success messaging, redirect URLs, list routing, and signup tags
* Publish draft pages to Sequenzy-hosted URLs, then copy or preview the public link from the page list or editor
* Connect a custom domain with CNAME verification and optional automatic Cloudflare DNS setup when available
* Track views and leads for each page from the landing-pages list
[View landing pages documentation](/concepts/landing-pages)
### WooCommerce Plugin On WordPress.org
Sequenzy for WooCommerce is now available through the WordPress.org Plugin Directory.
**What's included:**
* Install the WooCommerce plugin from its public WordPress.org listing
* Keep the guided Sequenzy pairing flow from `WooCommerce -> Sequenzy`
* Sync WooCommerce products, customers, guest buyers, orders, carts, and checkout activity
* Monitor plugin connection health and run manual store syncs from `Settings -> Integrations`
* Use the dashboard integration setup modal to open the WordPress.org install page instead of downloading a ZIP
[View WooCommerce plugin documentation](/concepts/woocommerce-plugin)
### Live Sequence Test Runs
You can now run a full sequence against one real subscriber before turning it loose.
**What's included:**
* Start a **Run sequence test** directly from the sequence builder
* Select one existing active subscriber so merge tags, branches, tags, lists, attributes, discounts, and webhooks use real subscriber state
* Compress waits with speed options like 60x, 120x, 240x, and 480x, so long onboarding or recovery flows can be checked quickly
* Send sequence emails through the test-email path with a `[TEST]` subject prefix while still creating normal send records for tracking and history
* Review recent test runs in the builder, including step status, accelerated wait timing, sent-email references, and failures
* Prevent accidental cross-sequence loops when test actions add tags or lists to the subscriber
Non-email actions run for real on the selected subscriber, so use a safe internal or test contact when checking destructive or webhook-heavy flows.
[View sequence documentation](/concepts/sequences)
### Custom Reply-To Domains For Reply Tracking
Reply tracking can now use your verified sending domain instead of the shared Sequenzy inbound domain.
**What's included:**
* Choose **Your domain** or **Sequenzy** for trackable reply-to addresses from `Settings -> Email Tracking`
* Use branded reply addresses like `reply+{id}@inbound.yourdomain.com` after the inbound MX record and SES receipt rule are active
* Fall back automatically to `reply+{id}@inbound.sequenzy.com` when a custom inbound route is not ready
* Show the required inbound MX record in domain setup, including automatic DNS creation where supported
* Register and clean up SES receipt rules for customer inbound domains as sending domains are verified or removed
* Validate inbound reply domains before threading replies into conversations
[View reply tracking documentation](/concepts/reply-tracking)
[View domain verification guide](/guides/domain-verification)
### Sequenzy Signup For Framer
The Sequenzy Signup form is now available as a Framer component, making it
easier to collect subscribers from Framer sites without copying custom embed
code.
**What's included:**
* A ready-to-use Framer component for email signup forms
* Form ID, list routing, tag IDs, copy, layout, colors, radius, font size, and
redirect settings in Framer's right panel
* Submissions sent directly to Sequenzy's public form endpoint, with no API key
required in Framer
* Support for both component-based setup and Framer's native Form webhook flow
[Open in Framer Marketplace](https://www.framer.com/marketplace/components/sequenzy/)
[View Framer documentation](/integrations/framer)
### WordPress Plugin On WordPress.org
Sequenzy Email Marketing is now available through the WordPress.org Plugin Directory.
**What's included:**
* Install the WordPress plugin from its public WordPress.org listing
* Keep the guided Sequenzy pairing flow from `Settings -> Sequenzy`
* Sync WordPress users, profile updates, and optional comment opt-ins
* Monitor plugin connection health from `Settings -> Integrations`
[View WordPress plugin documentation](/concepts/wordpress-plugin)
### Circular Countdown Timers And Expired States
The countdown block gains two round styles and control over what shows after the deadline passes.
**What's included:**
* Two new **Circle** styles: an outlined dial and a solid accent disc, each with a sweeping progress ring that empties as the days/hours/minutes/seconds tick down
* A **When expired** setting that lets you either freeze the timer on 00:00:00 or replace the digits with a custom message such as "Offer expired"
* A live preview of the expired state right in the block settings, so you can see exactly what recipients get once the timer runs out before you send
[View documentation](/concepts/countdown-timers)
### Countdown Timers
Add a live countdown timer to any campaign or automation email to create real urgency around a deadline.
**What's included:**
* A native **Countdown** block in the email editor, available from the block menu
* Four styles (Boxed, Minimal, Bold, Outlined) that automatically use your brand primary color
* Renders as a server-generated animated GIF that recalculates the time remaining on every open, so it works in Gmail, Apple Mail, and Outlook with no JavaScript or third-party service
* **Localized labels**: the DAYS / HOURS / MINS / SECS labels are translated to your company's email language automatically (Ukrainian, German, French, and 15 more), baked right into the image
* Pick a deadline with a calendar and quick presets (Tonight, Next Monday, End of month...), choose whether to show unit labels, and optionally link the timer to your offer page
The timer counts down from the moment each recipient opens the email. Because some clients (notably Gmail's image proxy) cache images, a re-open within a short window can briefly show a slightly stale time, but the first open is always accurate.
[View documentation](/concepts/countdown-timers)
### Dynamic Image Sources In The Email Editor
The image block's settings panel now makes it easier to point an image at a dynamic value.
**What's included:**
* A redesigned, tidier Image Settings panel with clearer source, alt text, and link sections
* One-click "dynamic source" suggestions that prioritize subscriber attributes and fields containing an image or URL
* Inside event-triggered sequences, the actual event payload fields are offered as `{{event.*}}` variables (not just a generic placeholder), so you can drop a product image or screenshot URL straight from the trigger event
### Remote And Local MCP Setup In Dashboard
The existing dashboard **MCP** button now shows both hosted remote connector setup and local stdio setup.
**What's included:**
* Copy the hosted remote MCP URL for Claude.ai, Claude mobile, and other Streamable HTTP clients
* Follow the local stdio setup path for Claude Desktop, Claude Code, Codex, Cursor, Windsurf, and VS Code
* Keep personal-key creation and manual local config snippets in the same MCP setup modal
* Open the full MCP docs directly from the sidebar MCP setup flow
[View MCP documentation](/concepts/mcp)
### Remote MCP Connector For Claude
You can now connect Sequenzy to Claude.ai and Claude mobile through a hosted MCP endpoint.
**What's included:**
* Add Sequenzy as a remote custom connector with `https://api.sequenzy.com/v1/mcp`
* Complete the Sequenzy OAuth flow from Claude without local config files
* Use the same MCP tools from browser and mobile clients that cannot launch a local stdio server
* Keep company selection available across API instances through shared Redis state
* Continue using the existing local `npx -y @sequenzy/mcp` setup for desktop and IDE clients
[View MCP documentation](/concepts/mcp)
### Smarter Sequence Template Picker
The sequence template picker now helps you choose what to launch next based on real subscriber data and projected impact, not just template popularity.
**What's included:**
* **Your next step** hero recommends the highest-impact template you do not already have live, with churn and recovery sequences prioritized over low-value nurture flows
* Projected monthly recovery is calculated from eligible subscribers, benchmark conversion, and your synced MRR or AOV (shows `?` when the estimate is not ready yet)
* Eligible counts use active, emailable subscribers only, with tooltips that explain the math and a link to view matching contacts in a new tab
* Templates you already have running move to a dedicated **Already live** section at the bottom with toned-down styling
* Template cards and the preview modal share the same layout: projection, setup time, payment requirements, and email count chips with helpful tooltips
* The preview modal scrolls properly on both sides and drops the old fake requirements checklist and benchmark clutter
[View sequence documentation](/concepts/sequences)
### Audience-Scoped Metrics And Revenue Attribution
The Metrics page now gives you a clearer view of performance by audience, email type, and business impact.
**What's included:**
* Filter dashboard metrics by all subscribers, a specific list, or a saved segment
* Combine audience filters with campaign, transactional, sequence, or all-email views
* See attributed revenue in the overview when your workspace has revenue-driving goals
* Review audience-scoped delivery trends, country breakdowns, reply metrics, and core engagement rates
* Identify list, segment, and email-type filters faster with icons in the dashboard controls
[View metrics documentation](/concepts/metrics)
### Double Opt-In For Subscriber Signups
You can now require new subscribers to confirm their email address before they become active marketing contacts.
**What's included:**
* Enable double opt-in from email tracking settings after setting a default sender profile
* Automatically create and customize the confirmation email, including the required `{{DOUBLE_OPT_IN_URL}}` link
* Keep pending subscribers unsubscribed until they confirm, then add their target lists, apply signup tags, and trigger the matching automations
* Use `optInMode` in the subscriber API to force double opt-in, confirm verified consent immediately, or obey the workspace setting
* Embedded signup forms now follow the workspace double opt-in setting
[View double opt-in documentation](/concepts/double-opt-in)
### Dark Mode For Everyone
Dark mode is now available to all users from the dashboard, without requiring an admin-only access flag.
**What's included:**
* Switch between light, dark, and system theme from the dashboard sidebar
* Use the command palette to select a theme directly
* Theme preferences persist across sessions for every user
### Matching Stop Conditions For Event Sequences
Event-triggered sequences can now stop only when the stop event matches the same object that started the sequence.
**What's included:**
* Stop conditions for event-triggered sequences can match stop-event fields against the original entry event, so a sequence can stop only when the same order, product, variant, or configured field path appears again
* Choose a matching field for stop conditions in the sequence builder when the trigger is event-based
* Matching stop conditions keep working through draft saves and compatible trigger edits
* Use matching stop conditions for flows such as "stop when the same order is refunded" or "stop when the same product is purchased again"
[View sequence documentation](/concepts/sequences)
### Campaign Computed Lists For Personalized Repeat Blocks
Campaigns can now store campaign-scoped data and compute per-recipient lists at send time, so repeat blocks can show subscriber-specific products, events, posts, offers, or other JSON rows.
**What's included:**
* Add `campaignData` JSON to a campaign for reusable item sources
* Define `computedLists` that filter, sort, limit, and optionally backfill rows from campaign data for each subscriber
* Use computed list keys as repeat block sources in the campaign editor
* Preview the computed output for an existing subscriber or inline subscriber data before sending
* Send, test-send, duplicate, and A/B test campaigns with the same computed-list rendering path
* Use the API and CLI to upload campaign data and computed-list definitions
[View campaign update API](/api-reference/campaigns/update)
[View computed-list preview API](/api-reference/campaigns/preview-computed-data)
[View email editor guide](/guides/email-editor)
### Subscriber Activity And Segment Accuracy
Subscriber profiles and segment filters now show more useful context and stay in sync after profile changes.
**What's included:**
* Subscriber activity timelines now group related send, delivery, open, and click events together
* Each sent-email activity item shows why the email was sent: campaign, sequence step, transactional email, or test email source
* Subscriber attribute edits from the dashboard and API now update segment filters more reliably after save
* Nested array custom attributes stay usable in segment filters when the underlying array values change
* Changing a bounced subscriber to a clean new email address reactivates the subscriber and clears soft-bounce state, while changes to known bounced addresses remain blocked
* Email HTML generation is more reliable for block emails and generated unsubscribe footers
[View subscribers documentation](/concepts/subscribers)
[View sequence documentation](/concepts/sequences)
### Signup Form Targeting, Segment Templates, And RTL Editing
Embedded signup forms, predefined segments, and the HTML editor now cover more common audience and localization workflows.
**What's included:**
* Signup form embeds can target selected lists and apply selected tags, with generated HTML/React snippets using the public forms endpoint
* The public signup form endpoint now accepts `lists` and `tags` query parameters while keeping existing hidden-field formats for deployed embeds
* Predefined segment templates now include more SaaS, ecommerce, and engagement audiences, including templates that use OR logic where it better matches the audience
* HTML editor direction handling now supports RTL emails while preserving existing LTR rendering behavior
[View signup form guide](/widgets/signup-form)
[View signup form API](/api-reference/widgets/submit-form)
[View subscribers documentation](/concepts/subscribers)
[View email editor guide](/guides/email-editor)
### Sequence Branching And Enrollment Controls
Sequence automation now has more precise branching and safer controls for when subscribers can enter a running sequence.
**What's included:**
* Add branch paths to sequence updates, so dashboard, API, CLI, and MCP clients can edit the right path in multi-branch automations
* Add sequence conditions for prior email link clicks and subscriber events, with link suggestions pulled from sequence emails where available
* Add an enrollment gate that can pause new sequence entries while allowing existing active and waiting runs to continue
* Record sequence lifecycle activity events for finished, stopped, and failed runs on subscriber profiles
* Send sequence lifecycle events through outbound webhooks when teams subscribe to those event types
[View sequence documentation](/concepts/sequences)
[View sequence update API](/api-reference/sequences/update)
[View outbound webhooks](/integrations/outbound-webhooks)
### External Subscriber IDs Across APIs And Integrations
Subscribers can now be matched by a customer-owned external ID across more APIs and integrations, reducing duplicate contacts when email addresses change.
**What's included:**
* Create, update, find, and delete subscribers by `externalId`
* Add and remove tags, trigger events, and send transactional emails using `externalId` when the subscriber already exists
* Import subscriber external IDs from CSV files and show them in subscriber tables and profiles
* Use external IDs from CLI, MCP, Zapier, and n8n workflows
* Map Supabase webhook columns into subscriber external IDs so future updates merge into the same subscriber even when email changes
[View external subscriber API](/api-reference/subscribers/external)
[View subscribers documentation](/concepts/subscribers)
[View Supabase integration](/integrations/supabase)
### Sequence Enrollment Cancellation From API, CLI, And MCP
You can now stop active or waiting sequence enrollments from automation clients without disabling the whole sequence.
**What's included:**
* Use the public API to cancel enrollments inside a required sequence
* Target one subscriber by `subscriberId`, or target all matching enrollments by entry-event field values
* Run field-value cancellation as a dry run before applying bulk changes
* Use the same workflow from the Sequenzy CLI and MCP `cancel_sequence_enrollments` tool
* Skill guidance and OpenClaw-facing docs now describe when agents should use subscriber-targeted or field-value cancellation
[View API reference](/api-reference/sequences/cancel-enrollments)
[View MCP documentation](/concepts/mcp)
### Outbound Webhooks Available To Workspaces
Outbound webhooks are now available from workspace settings and the public API, so teams can send email lifecycle events to their own systems without a private access flag.
**What's included:**
* Create and manage signed webhook endpoints from the dashboard
* Use the public `/v1/webhooks` API to list, create, update, test, replay, and inspect webhook deliveries
* Receive email lifecycle events for sent, delivered, delayed, bounced, complained, opened, clicked, and unsubscribed messages
* Webhook payloads include the Sequenzy subscriber ID and, when available, the customer-owned subscriber external ID
[View documentation](/integrations/outbound-webhooks)
[View API reference](/api-reference/webhooks/outbound)
### AI Images, HTML Import, And Website-Free Workspaces
Email creation and onboarding now work better when you need assets, existing HTML, or a workspace that does not start from a website URL.
**What's included:**
* Generate AI images from inside the email image dialog, with support for brand context, product/reference uploads, and background worker processing
* Import full HTML emails by uploading an HTML file directly into the editor
* Create workspaces without a website URL, with template filtering and product-info setup adapted for website-free companies
* Show a clearer landing-pages waitlist experience for workspaces waiting on hosted landing page tools
[View email editor guide](/guides/email-editor)
### Repeat Blocks For Dynamic Email Content
The email editor can now repeat a group of blocks for each item in a list, making product grids, event lists, recommendations, and transactional line items easier to build.
**What's included:**
* Add repeat email blocks that render collections from subscriber attributes, event data, transactional variables, and preview data
* Add repeat grid layouts for multi-column repeated content in the editor, preview, test sends, and sent email HTML
* Add repeat-block variable helpers and preview data tools so nested item variables are easier to inspect before sending
* Use repeat blocks in campaigns, transactional emails, sequence emails, and test sends through the same rendering path
[View email editor guide](/guides/email-editor)
[View transactional emails](/concepts/transactional-emails)
### Test Email Sending Safeguards
Test emails now behave more like a deliberate review step, with clearer recipients and stronger checks before anything leaves Sequenzy.
**What's included:**
* Test emails now require explicit recipients, carry source metadata, and are accounted for consistently across campaign, sequence, and transactional flows
* Transactional test sends run through stronger phishing-guard checks before sending
* Test-send activity now carries enough context to distinguish campaign, sequence, and transactional previews
* Domain setup checks are stricter before test emails use a sending domain
[View campaign documentation](/concepts/campaigns)
[View domain setup guide](/guides/domain-verification)
### Custom Tracking Domains And Branded Link Routing
You can now route email tracking through your own verified tracking domain, with safer shared fallbacks that avoid sending recipients through `sequenzy.com` or `api.sequenzy.com`.
**What's included:**
* Custom tracking domains can be connected with a CNAME and verified against Sequenzy's managed tracking target
* Click, open, unsubscribe, and Sequenzy branding links use the customer's verified tracking domain when one is configured
* Emails sent from shared `sequenzymail*` sender domains use matching shared tracking hosts where available
* Emails without a custom tracking domain fall back to `sequenzylink.com` instead of direct `sequenzy.com` tracking links
* Existing sent-email tracking links remain accepted, so older campaigns keep working while new sends use the updated routing
[View documentation](/concepts/tracking)
[View domain setup guide](/guides/domain-verification)
### Managed Replies, Regional Sending, And Pause Controls
Reply routing and deliverability controls are more visible and reliable across campaigns, sequences, and managed sending domains.
**What's included:**
* Accept inbound mail for managed domains so replies can be routed through Sequenzy-owned infrastructure
* Forward replies sent to system domains back to the configured destination inbox
* Automation sends now use tracked reply-to routing where available, so sequence replies are recoverable like campaign replies
* SES sending now routes by the sending domain's configured region, including region-aware system domains
* Admins can manage company sending limits and see pause metadata for campaigns and sequences
* Campaigns and sequences now show clearer pause reasons and pause sources in dashboard lists and detail screens
* Paused send failures are hidden from failed views, and paused sequence sends are treated as queued instead of failed
* Company-specific sender health thresholds can override the default bounce, complaint, and pause policy settings
[View campaign documentation](/concepts/campaigns)
[View sequence documentation](/concepts/sequences)
[View domain setup guide](/guides/domain-verification)
### Transactional Email APIs
Transactional emails now have broader public API and MCP coverage, so teams can manage templates without using only the dashboard.
**What's included:**
* Create transactional emails through the public API and MCP tools
* List, retrieve, and update transactional emails through the public API and MCP tools
* Update transactional names, slugs, sender profiles, reply profiles, templates, and enabled state through the API
* Use the same transactional management workflows from automation clients through MCP
[View transactional email documentation](/concepts/transactional-emails)
[View transactional create API](/api-reference/transactional/create)
[View transactional update API](/api-reference/transactional/update)
### Subscriber Attribute Editing And Segment Updates
Subscriber profile editing is more complete in the dashboard, and saved changes become usable in segment filters without extra manual work.
**What's included:**
* Subscriber attribute changes from dashboard edits, imports, webhooks, and payment syncs now update segment filtering in the background
* Add custom attribute creation and JSON editing tools on subscriber profiles
* Add manual subscriber refresh controls and clearer import progress handling
[View subscriber documentation](/concepts/subscribers)
### Bulk Subscriber Imports And Locked Discounts
Admins can import subscribers in larger batches, and Stripe discount actions can create codes locked to individual subscribers.
**What's included:**
* Allow company admins to run bulk subscriber imports
* Add subscriber-locked Stripe discounts for one-code-per-subscriber discount workflows
[View subscriber documentation](/concepts/subscribers)
[View Stripe integration](/integrations/stripe)
### Longer Campaign Spread Windows
You can now spread campaign sends over a configurable 1-72 hour window, giving larger campaigns and warmup sends more room to pace delivery.
**What's included:**
* Campaign scheduling now supports spread durations up to 72 hours
* Resume controls accept the same 1-72 hour spread range for paused campaigns
* The campaign wizard slider now exposes the expanded spread window
[View documentation](/concepts/campaigns)
### Commerce Product Automations, Back-In-Stock, And Subscriber Revenue Cleanup
Commerce workflows now carry product context end to end, from synced store products to sequence stop conditions and subscriber profiles.
**What's included:**
* Shopify products now sync with variants, stock state, images, URLs, pricing, and replenishment settings
* Shopify reconnects now verify the actual granted OAuth scopes before reusing a saved token, so stores missing product/order permissions are prompted to reconnect
* Product-level replenishment reminders can queue after Shopify and WooCommerce purchases, with product-level or variant-level matching
* Replenishment reminder jobs are skipped if the subscriber repurchases the same product before the reminder is due
* Sequences triggered by `ecommerce.replenishment_due` now default to stopping when the same product is purchased again
* The Shopify Notify Me storefront block captures back-in-stock requests, and product sync triggers `ecommerce.back_in_stock` when matching variants return to stock
* Sequences triggered by `ecommerce.back_in_stock` now default to stopping when the same item is purchased or goes out of stock again
* Back-in-stock and replenishment matching now documents the product fields Sequenzy checks: `provider`, `providerProductId`, `providerVariantId`, `lineItems[].providerProductId`, and `lineItems[].providerVariantId`
* Event-triggered sequences now support `matching_field` enrollment with `enrollmentFieldPath`, so you can block duplicate active runs for the same subscriber and event field value while still allowing separate runs for different products, variants, orders, or other event-scoped objects
* The dashboard suggests matching field paths from recent trigger event payloads, and the same field is available through the public API, CLI, and MCP `create_sequence` / `update_sequence` tools
* Subscriber profiles now show purchased products from Shopify/WooCommerce order line items alongside Stripe purchased products
* Subscriber tables now show `AOV` from `aov` or legacy `averageOrderValue`
* Legacy duplicate commerce attributes are cleaned up in the UI: `totalRevenue` is treated as an `ltv` fallback, and `averageOrderValue` is treated as an `aov` fallback
* Dynamic product previews now handle event-scoped product variables, so product blocks backed by `event.product` can still be previewed with sample products
* Product settings now show pending replenishment recipients in a denser list, and known subscribers open directly from that list
[View documentation](/integrations/shopify)
[View documentation](/concepts/woocommerce-plugin)
[View documentation](/concepts/events)
[View documentation](/concepts/sequences)
[View documentation](/concepts/subscribers)
[View documentation](/guides/email-editor)
### Dynamic Stripe And Shopify Discount Actions In Sequences, API, CLI, And MCP
Sequences can now create subscriber-specific Stripe and Shopify discount codes before sending follow-up emails, and the same explicit-step workflow is available from the dashboard, public API, CLI, and MCP tools.
**What's included:**
* A new Create Discount sequence action that creates dynamic Stripe coupons/promotion codes or Shopify discount codes during automation runs
* Discount context merge tags like `{{discount.code}}`, `{{discount.percentOff}}`, and `{{discount.expiresAt}}` for later emails in the same sequence
* Public sequence creation now accepts explicit `create_discount` steps alongside email steps
* MCP `create_sequence` and CLI `sequenzy sequences create --steps-file` now document and pass through discount action steps
* Sequence activation now blocks discount workflows until the selected provider is connected, so codes cannot fail at send time because the provider is missing
* Discount expiration dates are validated across the builder and worker so past dates are rejected before unusable codes are created
* Expiration can be set as a relative duration (`expiresInHours`) so flows like "valid for 48 hours" restart per enrolled subscriber, alongside the existing absolute `expiresAt` date
[View documentation](/api-reference/sequences/create)
[View documentation](/api-reference/sequences/enable)
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
### Nested Segment Logic, Event Filters, And Segment Filters
Segments can now express nested AND/OR logic, custom subscriber event conditions, and saved-segment composition.
**What's included:**
* Nested filter groups for rules like `last_login within 90 days AND (plan_end is empty OR plan_end is before today)`
* Custom event filters such as `saas.purchase:30d`, `saas.purchase:all`, and `saas.purchase:5:30d`
* Segment filters that reference another saved segment by ID, with cycle and depth guards during evaluation
* Existing flat segment filters remain supported and continue to use the legacy wire shape unless nested logic, event filters, or segment filters are used
* Dashboard, public API, CLI, and MCP surfaces now accept the v2 `root` filter shape
* Subscriber filters now include `is_empty` and `is_not_empty` operators for attributes and other nullable fields
[View documentation](/concepts/subscribers)
[View documentation](/api-reference/segments/create)
[View documentation](/concepts/mcp)
### AI Generation Across API, CLI, And MCP
You can now generate draft email content, sequence email drafts, and subject line variants from prompts through Sequenzy's public API, CLI, and MCP tools.
**What's included:**
* New generation endpoints for draft emails, sequence content, and subject line ideas
* `sequenzy generate email`, `sequenzy generate sequence`, and `sequenzy generate subjects` now return real generated content instead of placeholder messages
* Campaign creation now supports `--prompt`, with generated blocks used when available so the draft remains editor-compatible
* MCP campaign creation can generate prompt-based campaign content before creating the draft campaign
* `/v1` remains accepted as a backwards-compatible alias for `/api/v1`
* Generated sequences are capped at 10 emails across the API, CLI, and MCP surfaces
[View documentation](/api-reference/generate/email)
[View documentation](/api-reference/generate/sequence)
[View documentation](/api-reference/generate/subjects)
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
### Supabase Auth Emails Through Sequenzy SMTP
You can now route Supabase Auth emails through Sequenzy SMTP and provision the matching transactional templates from the Supabase integration flow.
**What's included:**
* One-click creation of the default Supabase auth transactional templates from the integration modal
* SMTP JSON payload support for selecting a Sequenzy transactional email by `slug` or `transactionalId`
* Support for both `variables` and `dataVariables` in SMTP template payloads
* Automatic shared-domain sender provisioning when Supabase defaults need a send-ready sender profile
* Updated setup guidance for mapping Supabase template variables to Sequenzy merge tags
[View documentation](/concepts/transactional-emails)
[View documentation](/integrations/supabase)
### Campaign-Specific Engagement Filters
Segments and recipient filters can now target specific sent campaigns instead of only rolling time windows, so you can build rules like "bounced Campaign A but did not bounce Campaign B" without any workarounds.
**What's included:**
* Engagement filters (`emailSent`, `emailOpened`, `emailClicked`, `emailBounced`, `emailComplained`) now accept a specific sent campaign as the value, in addition to the existing 7/30/90/180 day windows
* The dashboard value picker now groups rolling time windows and individual campaigns into separate sections so each option is obvious
* Filter pills now render campaign-scoped conditions naturally (`bounced in "Welcome email"` instead of a generic chip)
* The AI filter builder understands phrases like "bounced the welcome email but not the onboarding email" and resolves the campaign names against your sent campaigns
* `sequenzy segments create --filter-json` accepts `{"field":"emailBounced","operator":"is","value":"campaign:"}` for all engagement fields
* MCP `create_segment` documents the same `campaign:` value format for engagement filters
[View documentation](/concepts/subscribers)
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
### Target Specific Lists from the Stripe Integration
You can now choose which lists newly-synced Stripe subscribers join. The default is "all lists" for both the webhook and the backfill revenue sync, so the two paths stay consistent.
**What's included:**
* New **Lists for new subscribers** section in the Stripe authorize screen, with an "All lists" (default) or "Specific lists" picker
* Stripe webhook-driven subscriber creation honors the configured lists
* Stripe revenue sync honors the configured lists when creating new subscribers
* Existing subscribers are never re-added to or removed from lists by Stripe sync
**Heads-up for existing integrations:** Previously, the Stripe **revenue backfill** created new subscribers without adding them to any list, while the webhook path added them to every list. Both now use the same "all lists" default. If you re-run the revenue sync and don't want new Stripe customers added to every list, open the Stripe authorize screen and pick "Specific lists" (selecting none is equivalent to the old backfill behavior).
[View documentation](/integrations/stripe)
### OR Segments And Clearer Recipient Counts
Saved segments can now match either all filters or any filter, and the product now makes it clearer when a count includes every matched contact versus only active subscribers who can actually receive a campaign.
**What's included:**
* Saved segments now support both `AND` and `OR` filter logic across the dashboard, API surfaces, CLI, and MCP
* `sequenzy segments create` now supports `--match any` for OR-based segments
* MCP `create_segment` now documents `filterJoinOperator: "or"` for match-any segments
* Segment views now distinguish total matched contacts from active subscribers
* Campaign recipient selection now uses the active subscriber count for saved segments, so the estimate lines up with who will actually be sent
[View documentation](/concepts/subscribers)
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
### Conditional Email Content In The Editor, CLI, And MCP
You can now show or hide individual email blocks based on recipient data, and the same conditional block content now works across the dashboard editor, send pipeline, CLI, and MCP tools.
**What's included:**
* A new **Conditional Display** control in the email editor so blocks can render only when a merge-tag value matches a rule
* Support for conditions like `equals`, `contains`, `exists`, and numeric comparisons
* Preview and send-time evaluation using the recipient's real merge-tag data
* `sequenzy campaigns create|update` and `sequenzy templates create|update` now accept `--blocks-json` and `--blocks-file`
* MCP `create_campaign`, `update_campaign`, `create_template`, and `update_template` now accept `blocks` payloads for editor-compatible content
* Updated API docs for draft campaign updates when using block payloads
[View documentation](/concepts/campaigns)
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
[View documentation](/api-reference/campaigns/update)
### Default Reply-To Across Campaign Setup
You can now manage default reply-to behavior more directly when working with campaigns, including from the API, CLI, and MCP tools.
**What's included:**
* New campaigns created through the MCP API now inherit your company's default reply profile automatically
* `PUT /api/v1/campaigns/{campaignId}` now lets you update a draft campaign's reply-to using either a reply profile ID or an existing reply profile email
* `sequenzy campaigns update` now supports `--reply-to` and `--reply-profile` for draft campaigns
* The MCP `update_campaign` tool now exposes the same reply-to fields and validates unsupported combinations before sending the request
* Creating a new reply profile from the dashboard can now make it the company default and immediately apply it in campaign and transactional editors
[View documentation](/api-reference/campaigns/update)
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
### Dashboard Assistant Follow-Ups
The dashboard assistant is now better at ongoing conversations instead of acting like a one-shot shortcut box.
**What's included:**
* Context-aware starter prompts during onboarding, including questions like `What do I start with?` and `How can I add more about my company?`
* Dashboard prompts focused on review and next actions, including `Tell me what happened last week`
* Scoped performance prompts like `Show my top performing sequence` and best-campaign style questions now return the actual sequence or campaign instead of company-wide totals
* A floating follow-up chat that opens when you continue the conversation, so you can keep asking for explanation or next steps without losing context
* Product-info guidance inside the assistant, so it can point you to the right settings when your company context is thin
[View documentation](/concepts/metrics)
[View documentation](/concepts/sequences)
### CLI And MCP Errors Now Explain The Fix
CLI and MCP failures now return more useful recovery guidance instead of short raw error strings.
**What's included:**
* Human-readable failure descriptions for common auth, network, input, permission, and rate-limit issues
* Concrete next-step guidance in the returned error text so agents can retry with the right fix
* Direct `docs.sequenzy.com` links in CLI and MCP error output for faster self-recovery
* MCP tool failures are now explicitly marked as errors with `isError: true`
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
### CLI Login Links For Headless Environments
You can now log in to the Sequenzy CLI from headless terminals and agent shells without relying on the CLI to launch a browser window.
**What's included:**
* `sequenzy login` now prints the approval URL directly in the terminal
* The CLI also shows the approval code so you can verify the right session before approving it
* The login command keeps waiting in the terminal until approval is completed and the API key is stored locally
* A smoother authentication flow for remote shells, AI agents, and other environments where browser launching is unreliable
[View documentation](/concepts/cli)
### Ask The Dashboard To Do It
You can now use the expandable AI workspace on the onboarding screen and dashboard landing page to ask for metrics or trigger common setup actions in plain English.
**What's included:**
* Ask questions like `What are my metrics for last 30d?` and get a live summary without leaving the dashboard
* Type requests like `Create a welcome sequence` to open a matching starter flow directly in the sequence builder
* Use natural-language shortcuts for campaign creation and subscriber import from the same box
* Get the same assistant entry point during onboarding, so you can move from first login to first action faster
[View documentation](/concepts/metrics)
[View documentation](/concepts/sequences)
### Expanded Email Provider Coverage
Email provider detection now recognizes a much broader mix of mailbox providers, including regional consumer inboxes and hosted business platforms.
**What's included:**
* More provider buckets for regional mailbox hosts such as UKR.NET, Seznam, GMX, Onet, Interia, Bluewin, Telenet, and others
* More hosted-provider MX detection for providers such as Rackspace, Amazon WorkMail, OVH, and Titan
* Updated provider labels in filters so buckets like `iCloud` and `Custom domain` read more naturally in the UI
* The same background detection and ClickHouse-backed filtering model, now with broader provider coverage
[View documentation](/concepts/subscribers)
### Filter Subscribers By Email Provider
You can now filter subscribers by their email provider, including Google, Microsoft, Yahoo, iCloud, Proton, and other major mailbox hosts.
**What's included:**
* A new `Email Provider` filter in subscriber and segment builders
* Background detection for new subscribers and touched existing subscribers without blocking imports or API writes
* Canonical provider grouping so Gmail and Google Workspace are both treated as `Google`, and Outlook/Hotmail/Microsoft 365 are treated as `Microsoft`
* Provider values synced to ClickHouse for fast segment filtering
[View documentation](/concepts/subscribers)
### Adjustable Email Container Padding
You can now adjust the full email container padding directly from the theme controls, including reducing the side gutter all the way to `0px`.
**What's included:**
* **Horizontal padding** and **Vertical padding** sliders in the **Spacing** section of Email Themes
* Support for both company-wide default themes and per-email theme overrides
* Matching padding in the editor canvas, preview output, and sent email HTML
* An easier way to make emails feel less cramped on mobile without changing the content itself
[View documentation](/concepts/email-themes)
### Event Properties In Sequence Emails
You can now personalize sequence emails with properties from the event that started the automation.
**What's included:**
* Use merge tags like `{{event.city}}` or `{{event.alert.maxSpeed}}` inside sequence emails
* Event properties are stored on the sequence run, so later emails in the same sequence keep using the original event snapshot
* Automation test emails now accept event preview values so you can verify the output before activating the sequence
* Event property variables are shown in the email preview panel once you add them to your template
[View documentation](/concepts/sequences)
[View documentation](/concepts/events)
### Public And Private Subscriber Lists
You can now choose whether a subscriber list is public or private when you create it.
**What's included:**
* Public list names and descriptions appear in individual controls on the hosted subscriber email preferences/unsubscribe page
* Private lists stay internal and are omitted from those individual controls
* New companies still get `Product Subscribers` and `Newsletter Subscribers` by default, and both are created as public lists
* Public-list copy in the create-list dialog now warns you to use subscriber-friendly names
[View documentation](/concepts/subscribers)
### Sequence Steps Can Now Update Subscriber Lists
You can now add sequence steps that place a subscriber into a list or remove them from a list without leaving the automation builder.
**What's included:**
* A new `Update Lists` step in sequences with `Add to List` and `Remove from List` modes
* List-aware sequence actions in the visual builder and worker runtime
* Support for using subscriber lists as sequence routing primitives, not just trigger conditions
* Add-to-list actions now respect the target list membership state instead of duplicating active memberships
[View documentation](/concepts/sequences)
### Advanced Sender Routing
You can now separate the visible `From` address from the routing domain Sequenzy uses behind the scenes directly in sender profile settings.
**What's included:**
* Sender profiles can keep a visible `From` address on one verified domain and route through another verified sending domain in the same workspace
* Dedicated IP selection now follows the routing domain instead of inferring it from the visible sender address
* Campaigns, sequences, transactional emails, test sends, and forwarded replies all use the same authenticated-domain routing behavior
* Review screens show a subtle `via your-domain.com` hint only when visible sender and routing domain differ
[View documentation](/concepts/sender-routing)
### Dedicated IP Routing For Sending Domains
You can now see dedicated IPs in `Settings -> Domain`, track whether each one is still pending or ready, and connect a ready IP to one or multiple sending domains.
**What's included:**
* A dedicated IP management section inside domain settings
* Dedicated IP status visibility so pending purchases can appear before SES setup is finished
* Multi-domain assignment so one dedicated IP can power several sending domains
* Ready-only assignment so pending IPs stay visible but cannot be attached yet
* Domain detail pages now show when a domain is already routed through a dedicated IP
[View documentation](/concepts/dedicated-ips)
### Stripe Product Segments In CLI And MCP
You can now create Stripe-product subscriber segments directly from the Sequenzy CLI, and MCP now documents the exact filter shape for Stripe purchase-based segments.
**What's included:**
* `sequenzy segments list`, `sequenzy segments count`, and `sequenzy segments create`
* Native CLI flags for Stripe product filters like "bought", "didn't buy", and payment thresholds
* Explicit MCP `create_segment` guidance for `stripeProduct` filters
* Updated CLI and MCP docs so the Stripe-product segment workflow is discoverable
[View documentation](/concepts/cli)
[View documentation](/concepts/mcp)
### Stripe Sync Setup Controls
Stripe now gives you one more setup step after authorization so you can decide exactly which Stripe customers should sync into Sequenzy.
**What's included:**
* Choose which Stripe products count for customer sync
* Optionally keep syncing users who have not made any payment yet
* Pick which synced products are allowed to drive webhook-based updates
* Select extra customer or subscription metadata keys to carry into subscriber attributes
* Reopen these settings any time from the gear icon in `Settings -> Integrations`
[Stripe integration documentation](/integrations/stripe)
### WordPress And WooCommerce Integrations
You can now connect WordPress sites and WooCommerce stores to Sequenzy from `Settings -> Integrations`.
**What's included:**
* A new WordPress integration for syncing users, profile updates, and optional comment opt-ins
* A new WooCommerce integration for syncing products, customers, guest buyers, orders, and recovery events
* Install, connect, reconnect, disconnect, and sync controls in `Settings -> Integrations`
* Automatic initial sync after connection for both integrations
Both integrations are currently in beta.
[WordPress integration documentation](/concepts/wordpress-plugin)
[WooCommerce integration documentation](/concepts/woocommerce-plugin)
### Company And Per-Email Theme Controls
You can now customize the visual system behind your emails at both the company and single-email level.
**What's included:**
* Company-wide email themes that set the default look for all emails
* Per-email theme overrides with a reset option to inherit the company theme again
* Built-in starting presets: Default, Soft, Editorial, and Bold
* Controls for typography, spacing, radius, content width, padding, and core email colors
* Send-time rendering that uses the saved theme across campaigns, automations, transactional emails, and test sends
[View documentation](/concepts/email-themes)
### Event And Tag Trigger Visibility
You can now see which contacts received each event or tag in the last 24 hours, and which sequences those triggers feed into.
**What's included:**
* Event settings now show a last-24-hour contact count for each event
* Tag settings now show a last-24-hour contact count for each tag that was added
* Both settings pages now show which active sequences currently listen for that event or tag
* Paused sequences are shown separately so you can spot flows that would trigger if reactivated
* Subscriber activity now shows which sequence an event or added tag triggered, or would have triggered if the sequence is paused
[Events documentation](/concepts/events)
[Tags documentation](/concepts/tags)
### Reusable Email Components
You can now save blocks or full block sections from the email editor as reusable components, then insert them again in other emails without rebuilding them from scratch.
**What's included:**
* Save a selected block as a reusable component from the Components sidebar
* Save a top-level section made of multiple adjacent blocks
* Reuse saved components from the sidebar, the inline add-block menu, or drag and drop
* Generate a reusable component with AI from a prompt and save it straight into your library
* Saved components reuse the same block system as the editor, so they stay editable after insertion
[View documentation](/concepts/email-components)
### Free AI HTML Email Builder
A free tool for generating responsive HTML emails with AI chat, live preview, and code export - no account required.
**What's included:**
* AI chat that drafts subject lines, preview text, and email-safe HTML from a prompt, URL, or screenshot
* Block-based design editor with slash commands (type "/" to insert blocks)
* Live preview tab with desktop and mobile width toggle
* Editable HTML tab for direct code changes
* Drag-and-drop component sidebar with typography, media, buttons, layout, and footer blocks
* Copy and download actions for the final HTML output
[Try it free](https://www.sequenzy.com/tools/ai-html-email-builder)
### Custom HTML Blocks In The Email Editor
You can now insert a dedicated **HTML** block directly inside the visual email editor when you need to drop in custom markup without leaving the block workflow.
**What's included:**
* A new **HTML** block in the component picker and slash-command menu
* Inline code editing directly on the canvas, with a live preview below it
* Matching render behavior in the editor preview and sent emails
* Support for merge tags like `{{FIRST_NAME}}` inside your custom HTML snippets
* Existing full-email HTML import mode remains available for complete HTML documents
[View documentation](/concepts/html-blocks)
### Multi-Language Email Localization
You can now configure extra email locales at the company level, keep localized variants per template, and have Sequenzy pick the right language for each subscriber at send time.
**What's included:**
* Company-level localization settings for supported locales, fallback locale, subscriber attribute mapping, and raw value mappings
* Per-template localized variants with sync status tracking for `synced`, `stale`, `syncing`, and `failed`
* AI-powered sync from your primary language into the extra locales you support
* Send-time locale resolution across campaigns, automations, transactional template sends, and A/B test variants
* Read-only localization visibility in both CLI and MCP for company settings and template variants
[View documentation](/concepts/email-localization)
### Update Tags Action In Sequences
You can now add tag-management steps directly inside sequences from a single **Update Tags** action in the builder.
**What's included:**
* A new **Update Tags** step in the add-step menu
* An in-step selector to choose whether the step should add a tag or remove one
* Full support for editing existing tag steps after they are added
* Runtime execution for both add-tag and remove-tag actions when contacts move through a sequence
[View documentation](/concepts/sequences)
### Installable Sequenzy Skills
You can now install a versioned Sequenzy skill for AI agents from the public `Sequenzy/skills` repo.
**What's included:**
* A reusable `sequenzy-email-marketing` skill you can install with `npx skills add Sequenzy/skills --skill sequenzy-email-marketing`
* Guidance for authentication, stats, subscriber management, and transactional email workflows
* Clear notes on current CLI gaps so agents fall back to the dashboard or API when needed
* A dedicated skills repo that can grow with more Sequenzy-specific agent workflows over time
[View documentation](/concepts/skills)
[Browse the repo](https://github.com/Sequenzy/skills)
### Reliable Natural-Language Date Filters
Subscriber and segment date filters now use validated ISO dates and full natural-language parsing instead of compact shorthand values.
**What's included:**
* Built-in Added filter presets now use plain-English values like `7 days ago` and `30 days ago`
* Fixed dates like `2026-03-01` still work and are validated before use
* Natural-language expressions like `last week`, `today`, and `3 days from now` stay supported
* Unsupported shorthand inputs like `7d` and `24h` are no longer part of the date-filter contract
[View documentation](/concepts/subscribers)
### Natural-Language Date Filters
You can now use rolling phrases like `30 days ago` and fixed dates like `2026-03-01` directly in subscriber and segment filters.
**What's included:**
* Rolling date expressions like `7d`, `30 days ago`, and `3 days from now`
* Fixed date values like `2026-03-01` and `Mar 1 2026`
* Clear rolling-vs-fixed behavior: relative phrases re-evaluate over time, fixed dates stay fixed
* Date-aware custom attribute comparisons that accept the same date formats
[View documentation](/concepts/subscribers)
### Date-Aware Subscriber Attribute Filters
You can now segment subscribers using custom attributes that contain dates or full timestamps, including ISO datetime values like `2026-03-19T10:56:03+00:00`.
**What's included:**
* Date-only custom attributes like `2026-03-20` are normalized for range filters
* Full ISO datetime strings with offsets are supported for segment comparisons
* Exact-match and range filters now use intentional date parsing instead of partial numeric coercion
* Existing string and numeric attribute filters continue to work as before
[View documentation](/concepts/subscribers)
### Segment Triggers In MCP Sequences
You can now create sequences through MCP with the same saved-segment entry trigger available in the app.
**What's included:**
* `create_sequence` now accepts `trigger: "segment_entered"`
* You can pass a `segmentId` from your saved segments
* MCP resolves the segment name automatically so the created sequence is labeled correctly
* This works for both AI-generated sequence creation and explicit-step sequence creation
[View documentation](/concepts/mcp)
### Segment Exit Stops For Sequences
You can now optionally stop a segment-triggered sequence when a contact no longer matches that segment.
**What's included:**
* A new per-sequence setting on the **Segment entered** trigger
* Automatic cancellation of active and waiting steps when the contact leaves the triggering segment
* The same 8-minute fallback segment evaluation used for enrollments, so exits stay in sync with entries
* No change to baseline behavior for current segment members when you first activate the sequence
[View documentation](/concepts/sequences)
### Segment-Entered Sequence Triggers
You can now start a sequence when a contact newly enters one of your saved segments.
**What's included:**
* A new **Segment entered** trigger in the sequence builder
* Automatic evaluation after relevant subscriber data changes, plus a background check every 8 minutes
* Safe baseline behavior so existing segment members are not enrolled when you first activate a sequence
* Automatic re-baselining when you change the segment definition or reactivate the sequence
* Manual **Enroll Existing Subscribers** support when you do want to send the sequence to current segment members
This makes lifecycle automations like VIP onboarding, trial qualification, and at-risk follow-up much easier to build without relying on extra tags.
[View documentation](/concepts/sequences)
### Flexible Campaign Delivery Planning
You can now choose campaign start time and delivery strategy separately. This means you can schedule a campaign for a future date and still spread delivery over 1-24 hours, instead of choosing between those options.
**What's included:**
* Separate controls for when sending starts and how delivery is paced
* Scheduled + spread delivery support in the campaign wizard
* A clearer delivery summary during setup and review
* Existing Send Time Optimization support for both immediate and scheduled starts
* Warmup recommendations that now suggest spread without forcing immediate send
[View documentation](/concepts/campaigns)
### Automatic UTM Tracking for Email Links
You can now define account-level UTM templates and have Sequenzy append them automatically when email HTML is generated.
**What's included:**
* Account-level defaults for `utm_source`, `utm_medium`, `utm_campaign`, `utm_content`, and `utm_term`
* Template variables like `{{email.subject}}`, `{{link.text}}`, and `{{company.name}}`
* Per-link manual override from the email editor when a URL should stay untouched
* Automatic exclusions for unsubscribe, preferences, social, and legal links
* Consistent tagging across buttons, rich-text links, image links, CTA blocks, and product links
[View documentation](/concepts/utm-tracking)
### Delivery Delay Tracking
You can now see delivery delay metrics in your dashboard. When email delivery is temporarily delayed, Sequenzy tracks these events and surfaces them in the metrics section.
**What's included:**
* Delivery delay rate shown as a percentage of total emails sent
* Raw count of delayed emails
* Visual progress bar for quick assessment
* Only displayed when delays are detected, keeping your dashboard clean
Delivery delays are informational — delivery will continue to be retried automatically. Monitoring delays helps you identify potential deliverability issues early.
### Shopify Integration
Connect your Shopify store to Sequenzy and automatically sync customers, products, and order events.
**What's included:**
* **One-click OAuth setup** — Connect your Shopify store from Settings → Integrations
* **Automatic customer sync** — Subscribed customers are imported with their order history and spend data
* **Product catalog sync** — Products are synced and available as drag-and-drop email blocks in the editor
* **Real-time webhooks** — Order placed, cancelled, fulfilled, refunded, customer created, and checkout started events are tracked automatically
* **E-commerce tags and sync rules** — Built-in `ecommerce.customer` tag is auto-applied on first purchase, `lead` tag on customer creation, and `refunded` tag on refunds
* **Product email blocks** — New Commerce category in the editor with small, medium, and large product card layouts
**Requirements:** Shopify store with an active plan. Set `SHOPIFY_API_KEY` and `SHOPIFY_API_SECRET` environment variables.
### Enroll Subscribers at a Specific Step
You can now enroll subscribers at any step in a sequence — not just the beginning. This is especially useful when you add new steps to an existing sequence and want finished subscribers to continue from the new step.
**How it works:**
* Hover over any action node in the sequence editor and click the **Enroll** button
* Choose from finished subscribers or search for any subscriber by email
* Subscribers who already passed the selected step are automatically filtered out
* Selected subscribers start processing from that step, skipping all previous steps
**Use case:** You have a 3-step welcome sequence that 50 subscribers completed. You add steps 4 and 5. Instead of restarting everyone from step 1, enroll them at step 4 — they'll only receive the new emails.
[View documentation](/concepts/enroll-existing-subscribers)
### Simpler Domain Setup
Domain verification now requires only **3 DNS records** instead of 5. We replaced the previous DKIM approach (3 CNAME records) with a single TXT record, making setup faster and less error-prone.
**What changed:**
* **DKIM**: 1 TXT record instead of 3 CNAME records
* **SPF**: 1 TXT record (unchanged)
* **MX**: 1 MX record (unchanged)
* **Total**: 3 records instead of 5
### Send Emails Without a Custom Domain
You can now start sending emails immediately using the built-in `sequenzymail.com` domain — no DNS setup required. Every account gets a subdomain like `yourcompany.sequenzymail.com` automatically.
**Good for:**
* Testing your email flows before going live
* Quick experiments and prototyping
* Non-essential communication where inbox placement isn't critical
**Keep in mind:** The shared domain's reputation is shared across all users, so emails may land in spam. For best deliverability, set up a custom domain — which is now easier than ever with only 3 DNS records.
[View domain setup guide](/guides/domain-verification)
### Spread Over Time Campaign Delivery
You can now spread campaign sends over a configurable time window (1–24 hours) to protect your sender reputation. Instead of delivering all emails at once, Sequenzy distributes them linearly — the first batch sends immediately, with remaining batches spaced evenly across the window.
**Key features:**
* Choose "Spread over time" as a delivery option in the campaign schedule step
* Configure the delivery window from 1 to 24 hours using a slider
* Automatic warmup recommendation for accounts that have sent fewer than 10,000 emails and are targeting 1,000+ recipients
* Spread and Send Time Optimization are mutually exclusive — enabling one disables the other
**When to use it:**
* Warming up a new sending domain
* Sending to large lists for the first time
* Maintaining consistent deliverability with large campaigns
[View documentation](/concepts/campaigns)
### Email Analytics API
You can now retrieve email engagement metrics via the API. Get totals for sends, deliveries, opens, clicks, and bounces across any time period — perfect for dashboards, reports, and syncing to external tools.
**Endpoints:**
* `GET /api/v1/metrics` — Account-wide metrics
* `GET /api/v1/metrics/campaigns/:campaignId` — Per-campaign metrics
* `GET /api/v1/metrics/sequences/:sequenceId` — Per-sequence metrics with per-step breakdown
* `GET /api/v1/metrics/recipients` — Per-recipient engagement data (opens, clicks, unsubscribes)
**Key features:**
* Aggregated totals: sends, deliveries, unique opens, unique clicks, unsubscribes
* Calculated rates: delivery rate, open rate, click rate, unsubscribe rate
* Sequence step-by-step breakdown to identify drop-off points
* Recipient-level engagement for CRM sync and support lookups
* Filter by sliding window (1h, 24h, 7d, 30d, 90d) or custom date range
[View documentation](/api-reference/analytics/metrics)
### HTML Email Import/Export
The email editor now supports importing and exporting raw HTML templates. Switch to HTML mode to paste existing email templates or export your designs as HTML for use in other tools.
* **Import**: Paste HTML from any email builder and it converts to editable blocks
* **Export**: Download your email as clean HTML
* **HTML block**: A new block type for embedding raw HTML directly in your emails
### Email Management in Sequence Builder
You can now manage your email templates directly from the sequence builder:
* **Filter emails**: Toggle between used and unused emails to keep your workspace clean
* **Delete unused emails**: Remove emails that aren't referenced by any sequence step
* **Usage protection**: Emails in use by sequence nodes or A/B tests cannot be deleted
### Subscriber Filters Persist on Navigation
Subscriber list filters (search, sort, tags, segments, pagination) are now preserved in the URL. When you click into a subscriber's detail page and navigate back, your filters are exactly where you left them.
### Dodo Revenue Tracking
Revenue tracking for Dodo Payments webhooks has been improved with proper event deduplication, accurate MRR/LTV calculation across multiple subscriptions, and correct handling of one-time payments vs. recurring subscriptions. Provider logos now appear in the subscriber activity timeline for better visibility.
### n8n Integration
Sequenzy is now available as a community node in [n8n](https://n8n.io), the open-source workflow automation platform. Connect Sequenzy to hundreds of apps and build complex automation workflows with a visual editor.
Install the `n8n-nodes-sequenzy` community node to get started.
### Soft Bounce Rate Enforcement
Sequenzy now monitors soft bounce rates alongside hard bounces and complaints. If a campaign exceeds soft bounce thresholds, it will be automatically paused to protect your sender reputation.
Soft bounce thresholds are \~2-3x more lenient than hard bounces since they represent temporary delivery failures. You can view your soft bounce status on the Sender Health page with color-coded indicators.
### Bounce Diagnostics
Bounced emails now show detailed explanations to help you understand and resolve delivery issues:
* **Bounce type breakdown**: Permanent, Transient, or Undetermined with specific sub-types (e.g., "mailbox full", "invalid address")
* **Contextual tips**: Actionable guidance based on the specific bounce reason
* **Bounce severity**: Hard vs. soft bounce labels in the sent emails table
### Campaign Approval Flow
Large campaign sends now go through an approval step before sending. When a campaign targets a large number of recipients, it enters a "Waiting for Approval" state and requires admin review before it can proceed. This prevents accidental mass sends and gives you a chance to review before committing.
### Image Block Improvements
The image block in the email editor now supports:
* **Clickable images**: Add a link URL to make any image clickable
* **Alignment**: Position images left, center, or right
* **Percentage-based widths**: Set image width as a percentage (10-100%) in addition to pixel values
All options work consistently across email clients using email-safe table-based layout.
### A/B Test UX Improvements
The A/B test button in the sequence builder now appears on a long hover (1.5s) instead of immediately, preventing accidental clicks. Sequence enrichment flows have also been improved with better prompts and timing.
### Campaign Engagement Chart
Sent campaigns now include an hourly engagement chart showing opens and clicks over time. This helps you see when subscribers are most active and how engagement develops after sending.
The chart displays in your local timezone and handles multi-day campaigns with clear date labels.
### Adaptive Campaign Sending
Campaign sending now uses adaptive chunk sizing that adjusts based on your sending volume and delivery performance. This improves delivery rates for large campaigns by pacing sends more intelligently.
### Metrics Accuracy Improvement
Click events are now correctly counted as opens too — since clicking a link implies the email was opened. This applies to both individual campaign metrics and the aggregate metrics list, giving you more accurate open rate numbers.
### Provider-Specific DNS Records
The domain DNS setup page now formats record names based on your DNS provider. Most providers auto-append the domain suffix, so Sequenzy shows just the subdomain part. Route53 users see the fully qualified name instead. This eliminates a common setup mistake where users would end up with records like `mail.example.com.example.com`.
### Domain Verification Guards
All email sending paths (campaigns, sequences, transactional emails, conversation replies) now verify that your sending domain is verified before queuing emails. Previously, some paths could attempt to send from an unverified domain, which would fail silently.
### Subscriber Search in Test Emails
The test email panel now includes a search field to find subscribers by name or email. You can also send test emails to yourself even if you're not a subscriber — just click "Send to myself".
### Checkout Abandonment Tracking
Sequenzy now automatically detects when someone visits your payment page but doesn't complete the purchase. A `visited-payment-page` tag is applied to subscribers who have an expired checkout session or \$0 in spend, making it easy to target them with recovery sequences.
**How it works:**
* When a checkout session expires (Stripe, Dodo) or a subscriber has zero spend, they automatically receive the `visited-payment-page` tag
* The tag is automatically removed when any purchase event fires
* Use this tag to trigger a checkout abandonment sequence and recover lost revenue
**Setting up a recovery sequence:**
1. Create a new sequence with the trigger "When tag added: `visited-payment-page`"
2. Set the stop condition to "When tag removed" (so the sequence stops if they purchase)
3. Design your recovery emails — remind them what they're missing
This works automatically with Stripe and Dodo integrations. No additional code or configuration needed.
### Dodo Payments Integration Fix
Fixed an issue where Dodo Payments revenue sync could fail in live environments. Webhook setup validation has also been improved — you'll now get a clear error if you accidentally paste a webhook secret instead of an API key.
### Custom Email Fonts
You can now choose from 50+ fonts for your emails. Select a font in the Email Style panel (left sidebar) and it applies to your entire email.
**Available fonts:**
* **System fonts**: Arial, Helvetica, Georgia, Times New Roman, Verdana, Tahoma, Courier New, and more. These are universally supported across all email clients.
* **Web fonts**: Inter, Roboto, Open Sans, Lato, Montserrat, Poppins, Playfair Display, Merriweather, and 40+ more from Google Fonts. These render in modern email clients with graceful fallbacks.
The font picker shows a preview of each font so you can see how it looks before selecting. Web fonts include a note about email client compatibility.
[View documentation](/guides/email-editor#fonts)
### Automatic Stop Condition Sync
When configuring sequence triggers, Sequenzy now automatically sets sensible stop conditions based on your trigger type. This saves time and ensures your sequences stop at the right moment.
**How it works:**
* **Tag triggers**: When you trigger on tag added (e.g., "trial"), the stop condition auto-sets to "when tag removed"—so users exit when they're no longer in trial
* **List triggers**: When you trigger on contact added to a list, the stop condition auto-sets to "when removed from list"
* **Inactivity triggers**: When you trigger on inactivity (e.g., no "login" event for 14 days), the stop condition auto-sets to "when event received"—so re-engaged users exit immediately
The stop condition syncs automatically as you configure the trigger. You can always override it manually if needed.
### YouTube Video Block
Embed YouTube videos in your emails. The video block displays a thumbnail with a play button that links to the video. Supports width adjustment and left/center/right alignment.
### Dashboard Command Palette
Press Cmd K to open a fast command palette that lets you jump to any dashboard page (including tabbed views) and reopen your three most recent campaigns or templates.
### MCP Integration & CLI
Sequenzy now supports the [Model Context Protocol (MCP)](https://modelcontextprotocol.io), allowing AI assistants like Claude Desktop and Cursor to manage your email marketing directly.
**What you can do with AI:**
* Add and manage subscribers
* Create email sequences from natural language prompts
* Draft campaigns
* Send transactional emails
* View analytics and performance stats
* Generate email content with AI
**Quick setup:**
```bash theme={null}
npx @sequenzy/setup
```
This wizard logs you in, detects your AI clients (Claude Desktop, Cursor, Windsurf), and configures them automatically.
**New CLI tool:**
We've also released a command-line interface for terminal users:
```bash theme={null}
# Login
npx @sequenzy/cli login
# Add a subscriber
npx @sequenzy/cli subscribers add user@example.com --tag vip
# Send an email
npx @sequenzy/cli send user@example.com --template welcome
# View stats
npx @sequenzy/cli stats
```
**Personal API Keys:**
A new type of API key (`seq_user_`) that's tied to your user account rather than shared company-wide. Perfect for CLI/MCP use—each user has their own keys.
[View MCP documentation](/concepts/mcp) | [View CLI documentation](/concepts/cli)
### Inbound Webhooks with Payload Mapping
Connect external services like Cal.com, Typeform, and Calendly directly to Sequenzy without needing Zapier or other automation platforms.
Each webhook gets a **unique secret URL** — no API keys or special headers needed. Just paste the URL into your external service and it works.
**How it works:**
1. Create a sequence with a trigger like "When `call-booked` event received"
2. Copy the unique webhook URL from the trigger settings
3. Paste the URL into your external service (Cal.com, Typeform, etc.)
4. Send a test webhook — Sequenzy captures the raw payload
5. Map fields from the payload to Sequenzy fields (email, first name, custom properties)
6. Save the mapping — future webhooks trigger the event automatically
**Key features:**
* **No API keys needed**: The URL IS the authentication — just paste and go
* **Any payload format**: Sequenzy captures whatever your external service sends
* **Visual field mapper**: Click on values in the captured payload to map them to subscriber fields
* **Live preview**: See extracted values as you map fields
* **Auto-create subscribers**: Subscribers are created automatically if they don't exist
[View documentation](/integrations/custom-webhooks)
### Sent Emails List in Campaign Review
When reviewing a sent campaign, you can now see a complete list of all emails that were sent. View delivery status, open/click tracking, and individual subscriber details directly from the campaign review page.
### Discord & Reddit Social Links
Added Discord and Reddit to the social media block options in the email editor. You can now include links to your Discord server and Reddit community alongside Twitter, LinkedIn, Instagram, Facebook, and YouTube.
### Zapier Integration
Connect Sequenzy to over 6,000 apps using [Zapier](https://zapier.com). Automate your email marketing workflows by connecting to CRMs, forms, payment providers, and more—no code required.
**Available actions:**
* **Create or Update Subscriber**: Add leads from Typeform, Webflow, or any form tool
* **Add/Remove Tags**: Tag subscribers based on actions in other apps
* **Trigger Events**: Fire custom events to start automations
* **Delete Subscriber**: Handle unsubscribes from other systems
* **Find Subscriber**: Look up subscriber data by email
**Example workflows:**
* Add Typeform respondents as subscribers with their answers as attributes
* Tag Calendly bookings as "booked-call" and trigger a nurture sequence
* Sync Stripe customers with "customer" tag automatically
Navigate to **Settings → Integrations** to see setup instructions, or visit [Zapier's Sequenzy page](https://zapier.com/apps/sequenzy/integrations) to get started.
[View documentation](/integrations/zapier)
### Select All Subscribers for Enrollment
When enrolling subscribers into a sequence, you can now select all matching subscribers at once. A "Select all" checkbox makes it easy to enroll your entire filtered list without clicking each subscriber individually.
### Keyboard Shortcuts for Sequence Builder
Navigate the sequence builder faster with keyboard shortcuts:
* **G** - Open Goals modal
* **S** - Open Enroll Subscribers modal (when sequence is active/paused)
* **,** (comma) - Open Settings modal
Shortcuts are displayed in button tooltips. They respect input focus and won't trigger when you're typing in a text field or when modals are open.
### Send Test Email Button
A new "Send Test" button is now available in the email preview panel. Quickly send a test email to yourself or your team without leaving the editor. Previously, you needed to navigate to the campaign settings to send a test.
### Selective Subscriber Enrollment
When enrolling subscribers into a sequence, you can now choose exactly which subscribers to enroll. The enrollment modal shows each matching subscriber with their "date added" so you can make informed decisions about who to include.
**New features:**
* **Individual selection**: Check/uncheck specific subscribers
* **Date context**: See when each subscriber was added
* **Progress tracking**: Watch enrollment progress with a real-time counter
* **Bulk actions**: Select all or clear selection with one click
This is useful when you want to enroll only recent subscribers or exclude specific contacts from a sequence.
### Bulk Add to List
Select multiple subscribers from the subscribers page and add them all to a list in one action. Previously, you needed to add subscribers to lists one at a time or use the API.
**How to use:**
1. Go to **Subscribers** and select the subscribers you want to add
2. Click the "Add to List" button in the bulk actions bar
3. Choose the target list
4. All selected subscribers are added instantly
### Email Reply Tracking & Conversations
Track and manage replies to your emails with the new conversation inbox. When subscribers reply to your campaigns, sequences, or transactional emails, their responses are captured and organized into threaded conversations.
**Key features:**
* **Automatic reply capture**: Replies to any email are automatically tracked and linked to the original message
* **Conversation threading**: Multiple replies are grouped into conversations with full message history
* **Reply forwarding**: Optionally forward subscriber replies to your team's email address
* **Two-way conversations**: Reply directly to subscribers from the Sequenzy dashboard
* **Reply analytics**: Track reply rates alongside opens and clicks in your metrics
**How it works:**
1. Enable reply tracking in **Settings → Email Tracking**
2. Outbound emails automatically use a trackable reply address
3. When subscribers reply, messages appear in your **Inbox**
4. View conversation threads, reply to subscribers, or forward to your team
**Conversation management:**
* Mark conversations as open or closed
* View all messages in a threaded timeline
* See subscriber profile alongside conversations
* Search and filter by status, date, or subscriber
**Retention:**
Replies are retained based on your configured retention period (default: 30 days). You can adjust this in Settings.
[View documentation](/concepts/reply-tracking)
### Send Time Optimization
Deliver campaign emails at each subscriber's optimal time based on their historical engagement patterns. When enabled, Sequenzy analyzes when each subscriber typically opens emails and schedules delivery accordingly.
**How it works:**
* Enable "Send Time Optimization" when scheduling a campaign
* Sequenzy analyzes each subscriber's open patterns from the last 90 days
* Emails are delivered within a 12-hour window, timed to when each subscriber is most likely to engage
* Subscribers without enough engagement history receive emails at the scheduled time
**Requirements:**
Subscribers need at least 5 email opens in the last 90 days for their optimal time to be calculated. The campaign scheduling UI shows how many subscribers have computed optimal times.
**Analytics:**
After sending, view a delivery distribution chart showing how your campaign was spread across hours. This helps you understand how STO distributed your emails and correlate with engagement metrics.
### Campaign Revenue Attribution
See exactly how much revenue each campaign generates with the new attribution panel. When viewing sent campaigns, you'll now see conversions and tracked revenue directly attributed to that campaign.
**What's included:**
* **Conversions count**: Number of goal conversions attributed to the campaign
* **Tracked value**: Total revenue from attributed conversions
* **Goal breakdown**: See which goals drove conversions (if you have multiple goals)
Attribution uses a 24-hour window from email interaction (open or click) to conversion. This feature works with any goal you've configured, including the default revenue tracking from Stripe, Polar, Paddle, and Dodo integrations.
Navigate to any sent campaign to view its attribution metrics alongside engagement stats.
### Activity-Based Triggers for Sequences
You can now trigger automation sequences based on subscriber activity patterns. Two new trigger types are available in the sequence builder:
**Inactivity Trigger**
Start a sequence when a subscriber hasn't performed a specific event for a set number of days. Perfect for:
* Re-engagement campaigns for inactive users
* Churn prevention when users stop using key features
* Win-back flows for lapsed customers
**Event Frequency Trigger**
Start a sequence when a subscriber performs an event multiple times within a time window. Great for:
* Rewarding power users who complete actions frequently
* Identifying highly engaged subscribers
* Triggering upgrade prompts for heavy usage
**How to use:**
1. Create a new sequence or edit an existing one
2. Click on the trigger node
3. Select "Inactivity" or "Event frequency" from the trigger type dropdown
4. Choose the event to track and configure the time settings
### PostHog Integration
Connect your [PostHog](https://posthog.com) product analytics to trigger email automations based on user behavior. Send emails when users perform (or skip) specific actions in your product.
**What you can do:**
* **Trigger emails from product events**: Feature used, onboarding completed, checkout started
* **Build behavior-based segments**: Users who haven't used feature X in 7 days
* **Re-engage inactive users**: Detect users who stopped using your product
**How it works:**
1. Copy your webhook URL from Sequenzy Settings → Integrations
2. Add it as a Webhook destination in PostHog Data Pipelines
3. Events flow in real-time and trigger your automations
All PostHog events are prefixed with `product.` in Sequenzy (e.g., `product.feature_used`).
[View documentation](/integrations/posthog)
### GitHub @mention in AI Writer
Generate product update emails from your actual commit history and releases. In the AI email editor, type `@github owner/repo` and the AI will pull recent commits and releases to write accurate product update emails.
**Example:**
> "Write a product update email based on @github acme/saas-app from the last month"
The AI will fetch your latest commits and releases, then generate an email highlighting real features and improvements - not generic marketing copy.
### Auth Provider Integrations (Clerk & Supabase)
Automatically sync users from your authentication provider to Sequenzy. Every signup becomes a subscriber—no code required.
**Supported providers:**
* **[Clerk](/integrations/clerk)**: Sync users from Clerk authentication with full profile data
* **[Supabase](/integrations/supabase)**: Sync users from your Supabase database webhooks
**How it works:**
1. Copy your unique webhook URL from Sequenzy
2. Paste it in your Clerk or Supabase dashboard
3. Users automatically sync in real-time
**What gets synced:**
* Email, name, username, and profile data
* User created → subscriber added with `contact.subscribed` event
* User deleted → subscriber unsubscribed automatically
Use these integrations to trigger welcome sequences the moment someone signs up, without writing any code.
Navigate to **Settings → Integrations** to connect your auth provider.
[View Clerk documentation](/integrations/clerk) | [View Supabase documentation](/integrations/supabase)
### Send Transactional Emails via SMTP
You can now send transactional emails using the standard SMTP protocol, making it easy to integrate Sequenzy with any application that supports SMTP (Laravel, legacy systems, etc.).
**Connection details:**
* **Host:** `smtp.sequenzy.com`
* **Port:** 587 (STARTTLS), 465 (SSL/TLS), or 2525 (fallback)
* **Username:** `api`
* **Password:** Your Sequenzy API key
**Features:**
* Same security checks as the REST API (domain verification, rate limiting, bounce protection)
* Branding footer automatically added for free tier
* All emails appear in your dashboard with full tracking
* Up to 50 To recipients per message
```javascript theme={null}
// Node.js example with nodemailer
const transporter = nodemailer.createTransport({
host: "smtp.sequenzy.com",
port: 587,
secure: false,
auth: { user: "api", pass: "ek_your_api_key" },
});
await transporter.sendMail({
from: "you@your-verified-domain.com",
to: "recipient@example.com",
subject: "Hello",
html: "Sent via SMTP!
",
});
```
[View documentation →](/send-email/smtp)
### Creem Integration
Connect your [Creem](https://creem.io) account to automatically sync revenue data and power your email automations. Creem is an all-in-one payment platform that handles global commerce complexity including payments, subscriptions, and tax compliance.
**What gets synced:**
* **MRR & LTV**: Automatically sync Monthly Recurring Revenue and Lifetime Value for each subscriber
* **Status tags**: `customer`, `cancelled`, `churned`, `saas.monthly`, `saas.yearly`
* **Events**: `saas.purchase`, `saas.cancelled`, `saas.churn`, `saas.refund`, and more
Use these attributes to create powerful segments (e.g., "churned customers with LTV > \$500") and trigger automations based on subscription changes.
Navigate to **Settings → Integrations** to connect your Creem account.
[View documentation](/integrations/creem)
### Goals & Attribution
Track which emails in your sequences actually drive conversions with the new Goals feature. Using last-touch attribution, Sequenzy credits revenue and conversions to the most recent email a subscriber interacted with before converting.
**Key features:**
* **Company-wide goals**: Track overall revenue across all your emails
* **Automation-specific goals**: Measure performance of specific sequences
* **Revenue tracking**: See exactly how much revenue each email generates
* **Per-email breakdown**: Identify your highest-performing emails
**How it works:**
1. Create a goal tied to a conversion event (e.g., `saas.purchase`)
2. Optionally specify a revenue property to track amounts
3. Set your attribution window (default: 24 hours)
4. View which emails drove conversions and revenue
Works automatically with Stripe, Polar, Paddle, and Dodo integrations, or trigger custom events via the API.
[View documentation](/concepts/goals)
### Polar, Paddle, and Dodo Payments integrations
You can now connect three new payment providers to automatically track revenue events and sync subscriber data:
* **[Polar](/integrations/polar)**: For open source developers and digital product creators
* **[Paddle](/integrations/paddle)**: Complete payments infrastructure for SaaS with built-in tax compliance
* **[Dodo Payments](/integrations/dodo)**: Simple payments for indie developers
All three integrations work the same way as Stripe—connect your account, set up webhooks, and Sequenzy automatically tracks purchase events, cancellations, refunds, and more. Use these events to trigger automations like onboarding sequences, win-back campaigns, or churn prevention emails.
**Tracked events:**
* `saas.purchase`, `saas.purchase_monthly`, `saas.purchase_yearly`
* `saas.cancelled`, `saas.churn`, `saas.payment_failed`, `saas.refund`
Navigate to **Settings → Integrations** to connect your payment provider.
### A/B test sequences
You can now add A/B test steps to your automation sequences. Split your subscribers into two groups and send different email variants to measure which performs better.
### A/B test email campaigns
You can now run A/B tests on your email campaigns to optimize for better engagement. Split your audience and test different subject lines, email content, or sender names to see which version performs best.
**How it works:**
1. Create an A/B test step in your automation flow
2. Set the split percentage (e.g., 50/50 or 70/30)
3. Design variant A and variant B emails
4. Monitor results to see which variant wins on opens, clicks, or conversions
Use A/B testing to continuously improve your email performance with data-driven decisions.
### Tags on Stripe sync
When syncing revenue data from Stripe, Sequenzy now automatically applies tags based on subscription status:
* **Status tags**: `customer`, `trial`, `past-due`, `cancelled`, `churned`
* **Billing interval tags**: `saas.monthly`, `saas.yearly`
This makes it easy to segment and target customers based on their subscription state (e.g., find all churned yearly customers, or trial users approaching conversion).
### Quick filters for subscribers
Added more quick filter options to the subscribers list, making it faster to find the subscribers you're looking for. Filter by engagement status, subscription state, and more with a single click.
### Revenue data in subscriber details
The subscriber detail page now displays revenue information (MRR and LTV) directly, giving you a complete view of each subscriber's value without leaving the page.
### Transactional email events linked to subscribers
Transactional emails sent via the API are now properly linked to subscribers by email address. This means email events (sent, delivered, opened, clicked) now appear in the subscriber's activity history, giving you complete visibility into all communications with each contact—both marketing and transactional.
### Embeddable signup form widget
You can now generate a customizable HTML signup form to embed on any website. Navigate to **Settings → Embed Widget** and click on the Form widget to access the visual builder.
**Customization options:**
* **Form Style**: Choose between stacked (button below) or inline (button side-by-side) layouts
* **Placeholder Text**: Customize the email input placeholder
* **Font Color**: Set the input text color
* **Button Text & Color**: Customize the submit button appearance
* **Success Message**: Configure the confirmation message with custom font color and size
* **List Targeting**: Add subscribers to specific lists or all lists
The generated HTML is self-contained with inline styles—just copy and paste into any website. No JavaScript SDK required.
[View documentation →](/widgets/signup-form)
### Email deliverability checker
While editing any email, you'll now see a real-time deliverability score next to the Desktop/Mobile buttons. This rule-based checker analyzes your email content and predicts inbox placement without any AI calls.
**What it checks:**
* **Subject line** (25% of score): Length, spam trigger words, excessive caps, punctuation, emoji usage
* **Preview text** (15% of score): Presence, length, whether it duplicates the subject
* **Content** (40% of score): Text-to-image ratio, link count, unsubscribe link, spam triggers
* **Technical** (20% of score): Sender address, reply-to configuration
**Scoring:**
* **A (90+)**: Likely lands in Primary inbox
* **B (80-89)**: Good deliverability, may land in Promotions
* **C-F (under 80)**: Review flagged issues before sending
Click the score pill to see a detailed breakdown and specific issues to fix.
### Stripe revenue sync
When you connect your Stripe account, Sequenzy now automatically syncs revenue data for all your subscribers. This adds two key attributes to each subscriber:
* **mrr**: Monthly Recurring Revenue (normalized from any billing interval)
* **ltv**: Lifetime Value (total payments minus refunds)
You can use these attributes to create powerful segments like "high-value customers" or "churned subscribers with high LTV", and trigger automations based on subscription changes.
A manual "Sync Revenue" button is also available in Settings → Integrations to re-sync data at any time.
### Add subscribers to specific lists via API
When creating subscribers via the API, you can now specify which lists they should be added to. Pass an array of list IDs in the `lists` parameter to add the subscriber to specific lists. If `lists` is omitted or empty, the subscriber will be added to all lists.
```json theme={null}
{
"email": "user@example.com",
"lists": ["list_abc123", "list_def456"]
}
```
### Dynamic segments
Segments now support filtering by email engagement metrics like opens, clicks, and delivery status. Create segments such as "subscribers who opened any email in the last 30 days" or "subscribers who haven't clicked in 90 days" to target your most (or least) engaged audience. Custom event filtering is coming soon.
### AI-powered segment generation
You can now describe the audience you want to target in plain English, and our AI will generate the segment filters for you. Simply click the AI button in the segment builder, describe your target audience (e.g., "subscribers who opened an email in the last 30 days but haven't clicked"), and the AI will create the appropriate filter rules.
### Geographic distribution map
The Metrics page now includes a geographic distribution section with an interactive world map. See where your subscribers are engaging with your emails by country, with metrics including opens, clicks, open rate, and click rate. Hover over any country to see detailed engagement data.
### Filter metrics by email type
You can now filter your Sent Emails and Metrics pages by email type to see how different types of emails perform:
* **Campaigns**: Bulk marketing emails sent to subscriber lists
* **Transactional**: One-off emails triggered by your application (order confirmations, password resets, etc.)
* **Sequences**: Automated emails from your automation workflows
This helps you understand engagement patterns across different use cases and optimize each type independently.
### File attachments for transactional emails
You can now send file attachments with your transactional emails. Attachments can be provided as Base64-encoded content or as URLs that we fetch on your behalf.
* **Base64 content**: Include the file content directly in your API request
* **URL-based**: Provide a URL and we'll fetch the file when sending
* **40MB limit**: Maximum total attachment size per email
* **Any file type**: PDFs, images, documents, and more
```json theme={null}
{
"to": "user@example.com",
"slug": "invoice",
"attachments": [
{
"filename": "invoice.pdf",
"path": "https://example.com/invoices/123.pdf"
}
]
}
```
### Multiple recipients
Transactional emails now support multiple To recipients.
* **Multiple `to` addresses**: Send to up to 50 recipients at once
* **Automatic deduplication**: Duplicate To addresses are handled automatically
```json theme={null}
{
"to": ["user1@example.com", "user2@example.com"],
"slug": "order-confirmation"
}
```
### Added Teams Functionality
Added comprehensive teams functionality allowing you to collaborate with team members. You can now add team members by email, assign roles (admin or viewer), update member roles, and remove team members. Team members can collaborate on campaigns, subscribers, and other resources within your company workspace.
### Custom sender and reply-to for transactional emails
You can now customize the `from` and `replyTo` addresses for transactional emails.
* **Custom from**: Use any verified domain (e.g., `"Notifications "`)
* **Custom replyTo**: Direct replies to any email address