accept_account_suggestions
ChatGPTCreate accounts from suggested email domains. Each domain becomes an account (externalId and domain set to the domain, name derived from it) with the domain's contacts that belong to no account as members. When one account already uses the domain, contacts are added to it; with several, the domain is skipped (multiple_accounts). A domain whose contacts already partly belong to another account is skipped (already_in_account); domains without eligible contacts are skipped (no_contacts). Up to 25 domains per call; personal, disposable and the workspace's own sending domains are rejected. Keeps existing roles, runs no sync rules or segment-entered sequences, and a retry does not duplicate accounts or members; truncated means contacts were left out because an account holds at most 5,000 members. Fails with a 409 error while contacts use a custom attribute named account or account.*. Contacts added as members get their account. attributes rewritten, which changes segment membership and {{account.}} merge values.
activate_integration_pixel
ChatGPTInstall the Shopify storefront tracking pixel on the connected store, or repoint an existing one at this account. This is what turns on product views, cart activity, and browse abandonment - the data every browse-abandonment and cart-recovery sequence depends on. Idempotent: an already-live pixel returns changed: false. Events start flowing on the next storefront visit and nothing is backfilled for the period the pixel was off, so run it before, not after, building the sequence. If the store granted an older permission set, this fails with a message naming the reconnect step rather than silently doing nothing. Shopify only.
add_ab_test_variant
ChatGPTAdd a variant to a draft campaign or sequence A/B test. Sequence variants receive their own editable email template. Variants cannot be added after the test has started. Sequence tests whose parent sequence is active require confirmLiveChange. On an active sequence, contacts who reach the step afterwards can receive the new variant.
add_account_member
ChatGPTAdd a contact to an account (creating the contact when the email is new). Re-adding an existing member with a role updates the role; without a role keeps the current one. A new contact created here can start contact_added sequences or receive a double opt-in email.
add_receiving_domain
ChatGPTAdd the workspace's receiving domain: a domain or subdomain whose mail should reach the inbox. Once verified, replies to emails from all sending domains use reply addresses on it. Then the user publishes the returned MX record (and TXT record when listed) and you call verify_receiving_domain; the first verification turns Inbox on. A workspace has one receiving domain: a second returns 409 limit_reached before any DNS check (remove the current one first, after confirming with the user). A domain that already receives email elsewhere (its MX points at Google Workspace, Microsoft 365, Cloudflare Email Routing...) returns 409 domain_has_mailbox: suggest a subdomain such as support.acme.com and confirm with the user. 503 dns_check_failed means the MX lookup got no answer; retry in a minute. created is false when the workspace already has the name (returned unchanged, no check). The first receiving domain also sets replyTrackingDomainMode custom. Owner or admin only.
add_sending_domain
ChatGPTAdd and configure a sending domain. A domain belongs to exactly one company and cannot be moved or removed through the API, CLI or MCP afterwards, so confirm the target company with the user before adding. Before calling verify_sending_domain, publish the DKIM record from website.dnsRecords (when dnsRecords.platformDnsRecords is present, publish those CNAMEs instead: active and spare DKIM selectors plus a recommended bounces CNAME; only required entries block verification), the bounce records described by website.bounceRecords (its cnameRecord when style is cname, otherwise spf.record and mailFrom.mxRecord; never both at the same name), and DMARC when present. Tracked links use the company tracking domain shared by every sending domain; the first domain creates it on its root (links.<root>) and returns its CNAME as dnsRecords.trackingRecord. It is optional and never blocks verification or sending: until it verifies, links use the shared Sequenzy domain. Manage it with set_tracking_domain. Publishes Sequenzy-side DNS records for the domain in Sequenzy's public DNS zone, queues an automated domain risk review, and creates a sender profile for the domain.
add_subscriber
ChatGPTAdd one subscriber. Status is only applied when creating a new contact; use update_subscriber to change an existing contact's status. The subscribers:write scope covers listIds in this call. Matching sequences enroll by default (REST enrollInSequences), including tag_added when tags are set in this call, without requiring a list; pass enrollInSequences false to skip, and automations:trigger is required for enrollment. For multiple contacts or CRM records, use create_subscriber_import instead of looping this tool. For an email-only batch going into one list, add_subscribers_to_list is also available. Can email the contact at once: enrolled sequences send, and double opt-in (optInMode or company setting) sends a confirmation email.
add_subscriber_note
ChatGPTAdd an internal note to a subscriber. Provide email or externalId to identify the subscriber.
add_subscribers_to_list
ChatGPTBulk add existing or new subscribers to a subscriber list from an email array. Existing subscribers are added to the list without requiring a per-subscriber update call. Can email the added addresses: double opt-in confirmations when required, and matching sequences when enrollInSequences is true; overwrite updates existing contacts.
archive_sequence
ChatGPTArchive a sequence and stop new enrollments. Archived sequences remain available in the dashboard's archive. Contacts still in the sequence are cancelled when their next step runs; unarchiving restores a draft but not those enrollments.
attach_product_file
ChatGPTAttach a file, such as a PDF guide, to a product in your catalog by public URL, so the sequence emails Sequenzy sends after someone buys from your own store can include a download link ({{event.download.url}} and {{event.download.name}}). Sequenzy does not sell products or take payments. Replaces any file already attached to the product.
bulk_add_subscriber_tags
ChatGPTAdd tags to up to 500 existing subscribers in one call, identified by emails, externalIds, or subscriberIds. Built for reconciling historical or derived tags: subscribers that do not exist are reported in notFound instead of being created, and tag automations do NOT run unless triggerAutomations is true. Needs the subscribers:tag scope; a tag name that does not exist yet also needs tags:write. Use add_subscriber or update_subscriber for single-contact changes.
bulk_remove_subscriber_tags
ChatGPTRemove tags from up to 500 existing subscribers in one call, identified by emails, externalIds, or subscriberIds. Subscribers that do not exist are reported in notFound. Needs the subscribers:tag scope; the broader subscribers:write scope also satisfies it. Use this to roll back or reconcile a derived-tag backfill. Segment membership is re-evaluated, so running segment-entered or -exited sequences can email affected contacts.
bulk_update_conversation_spam
ChatGPTMove up to 100 conversations to Spam (spam true) or back to the inbox (spam false). Returns updatedIds, unchangedIds and notFoundIds; retrying is safe.
bulk_update_conversation_status
ChatGPTOpen or close up to 100 conversations in one call, e.g. to close every conversation returned by list_conversations. Returns updatedIds, unchangedIds (already had the status) and notFoundIds (missing or in another company); only changed conversations are rewritten, so retrying is safe.
cancel_campaign
ChatGPTCancel a campaign. Stops scheduled and sending campaigns (also works for paused and approval-pending ones). Remaining emails will not be sent and the campaign cannot be restarted - this cannot be undone.
cancel_push_campaign
ChatGPTStop a scheduled or sending push campaign. Unsent notifications are skipped; delivered ones cannot be recalled.
cancel_sequence_audience_enrollment
ChatGPTStop an audience enrollment run. A queued run is cancelled immediately; a running run stops after the batch it is currently enrolling. Contacts already enrolled stay in the sequence (use cancel_sequence_enrollments to remove them). A cancelled run cannot be resumed; a new run is needed to enroll the remaining contacts.
cancel_sequence_enrollments
ChatGPTCancel active/waiting enrollments in one sequence. Provide sequenceId and exactly one target: cancelAll to drain every active/waiting enrollment (use this to fully stop a live sequence instead of only freezing enrollment), subscriberIds for a specific batch, subscriberId for one subscriber, or fieldValues to match stored entry event properties. Every bulk target defaults to dryRun, so pass dryRun false to actually cancel. Bulk cancellation is capped per call: while the response reports remainingCount above zero, call again with the same arguments until it reaches zero. Cancelled enrollments cannot be restored; re-enrolling starts over without the original entry event properties.
cancel_subscriber_operation
ChatGPTStop future work for a queued/running tagging operation. Already applied tags are retained. Tagging cancellation requires subscriber tagging access. A cancelled operation cannot be resumed; tagging the remaining contacts needs a new start_subscriber_operation call.
cancel_team_invitation
ChatGPTCancel a pending team invitation. Invitations that have already been accepted cannot be cancelled. A cancelled invitation cannot be restored; inviting the address again creates a new invitation link.
check_email
ChatGPTCheck a saved campaign, sequence email step or template before sending: the email checker rules plus live verification of every link and image (broken pages, dead domains, missing https://, placeholder or staging URLs, broken images). Checking against a stored subscriber ID is unavailable here; omit it or pass a policy-checked inline subscriber. Read-only.
clear_email_ai_style
ChatGPTClear the company's saved AI appearance and restore normal defaults for future generations. Existing emails stay unchanged. Requires emails:write. Get and review the current style first; a conflict must not be retried automatically.
clear_frequency_cap
ChatGPTTurn the company frequency cap off. Sequences keep their frequencyCapEnabled setting, but nothing is skipped until a cap is set again with set_frequency_cap. Sequence emails the cap would have skipped are delivered once it is cleared.
configure_sending_domain
ChatGPTDeprecated: tracking is company-wide; prefer set_tracking_domain. Sets <trackingPrefix>.<domain> as the company tracking domain when the company has none. Repeating the company's current tracking hostname is a no-op; a different one changes nothing and the response message says so (use set_tracking_domain to change it). Publish the returned website.tracking.cnameRecord; sending never waits for it. When the company has no tracking domain, the background verification sweep registers the new hostname with Cloudflare; once verified, tracked links in new emails use it.
configure_sequence_inbound_webhook
ChatGPTCreate or update the mapping and sample attached to a sequence inbound_webhook trigger. The response omits the endpoint secret and credential-bearing URL; a human can copy it from the returned sequence dashboard URL. Once a mapping is saved, posts from external systems to the secret URL enroll contacts; clearing it stops enrollment from those posts.
connect_landing_page_domain
ChatGPTConnect a custom domain. Omit landingPageId for the legacy workspace-wide domain, or provide it to dedicate the hostname to one page at the domain root. Returns DNS and verification details. Registers the hostname with the hosting provider (Vercel); connecting a new workspace-wide domain releases the previous workspace hostname, so pages stop loading there.
create_ab_test
ChatGPTCreate a campaign A/B test or convert a sequence email node into a typed A/B test node. Provide exactly one of campaignId or automationNodeId. Control variant A is created automatically from the current email. Campaign tests may add variants later; automationNodeId conversions require at least one variants[] entry to compete with control variant A. A conversion moves that step's copy off the sequence node and onto the test's variants: from then on update_sequence_node cannot edit its subject, previewText, or blocks, and every content change has to be applied per variant with update_ab_test_variant (get_ab_test lists them). The response echoes this in contentEditing. On an active sequence, contacts reaching the converted step start receiving the competing variants at once.
create_account_health_fix
ChatGPTBuild the draft sequence an account health insight asks for, from an unhandled_event or missing_sequence insight (its primary action kind is create_sequence). Creates an inactive sequence with its timing and empty, titled email steps: for unhandled_event, triggered by the event and named for the moment (for example New customer onboarding for saas.purchase); for missing_sequence, with the name, trigger (contact added, an event, or manual enrollment) and steps from the insight's evidence. Like a sequence from a template, a new draft has its emails written with AI: enrichmentStatus is processing while they are written (get_sequence reports progress), or not_queued when writing could not start (opening the sequence in the dashboard starts it; do not build again). Running it again returns the same draft with created false; steps that still have no email (for example a check's own draft nobody opened yet) are written then, with enrichmentStatus, and existing emails are never rewritten. 409 IN_PROGRESS when another build of the same insight is running; 400 for other insight types. Show it with get_sequence; enable_sequence only works once every email step has an email, and only after the user approves. Requires sequences:write.
create_accounts_from_organization_id
ChatGPTStart a background job that creates one account per distinct propertyKey value and adds each contact seen with it as a member. Accounts are named from nameKey, otherwise after the work email domain most of their contacts share; existing names, domains and roles are kept. No emails are sent, no sync rules run and no segment-entered sequences start. Returns jobId, alreadyRunning (a run for the same key was already queued or running, so none was started) and job; check progress with get_account_organization_id_job. Reruns update the same accounts instead of duplicating them. Only call after the user confirmed the preview. Fails with a 409 error while contacts use a custom attribute named account or account.*. Turns Accounts on for the workspace and rewrites members' account.* attributes; existing accounts with the same ID gain members.
create_audience_sync
ChatGPTPush a segment to a Meta custom audience and keep it synced on a schedule. Provide segmentId for an existing segment OR predefinedSegmentId for a ready-made template (for example "zero-ltv", "no-purchase-1y", "recent-buyers", "high-spenders-ecom", "non-buyers", "engaged") - the template segment is created automatically on first use. The first upload runs immediately. Note: audiences are add-only; subscribers who later leave the segment stay in the Meta audience.
create_campaign
ChatGPTCreate a new campaign. Omit all content fields to create an empty draft. prompt generates net-new content from natural language. blocks are finished caller-supplied Sequenzy content and html is preserved/imported markup. Pass emailPreset with native blocks to set Style > Format (minimal or branded); style is a prompt-generation hint only. Defaults to draft; status 'sent' only archives an already-sent campaign. With prompt, the AI writer can fetch URLs named in the prompt and pages on the company's website.
create_campaign_for_audience
ChatGPTCreate a blank campaign draft for selected contacts, a complete filtered contact group, or a complete email-activity drilldown. Saves a frozen, distinct group of up to 100,000 contacts (8 MiB); does not send email. Requires campaigns:write and subscribers:read, plus analytics:read for activity. Returns selectedCount and currently eligibleCount. Review/update the draft and schedule separately. Existing get_campaign, get_campaign_audience and update_campaign read, replace or clear targetLists.
create_campaign_goal
ChatGPTCreate a persisted event, subscriber-attribute, or tag-applied conversion goal for one email campaign. SMS campaigns are not supported. Event goals (the default triggerType) require triggerEventName; attribute_change goals require attributePath; tag_added goals require triggerTagName. Campaign goals are attributed to recipients who were sent the campaign (opens/clicks still win when present). Use this to measure outcomes such as signup or becoming a customer on a one-off campaign. Distinct from company-wide goals and from sequence goals.
create_campaign_variation
ChatGPTSave content as a new ready campaign variation, for example a copy of a version to take in another direction. Send blocks or html. The campaign email does not change. Pass parentVariationId to save it as a branch of that variation.
create_company
ChatGPTCreate a company with a website domain, or set noWebsite and provide a name. Optionally provide a business description and create a four-email welcome sequence. Requires a personal connection; company-scoped access cannot create another workspace. Website creation queues brand processing and this tool polls for completion. Looks up the given website domain with an external brand-data provider (brand.dev), and makes the new company the selected company for later calls without companyId.
create_email_component
ChatGPTCreate a reusable email component from a block list. Component names are unique per company. Use set_default_email_component instead when the goal is to change the footer every email gets.
create_form
ChatGPTCreate and publish a saved signup form whose opaque formId is a client-safe public capability. The selected lists, tags, duplicate behavior, and success action stay server-side; no API key is needed in the deployed form. This creates the email/name fields only - add typed custom fields (select, textarea, hidden, ...) afterwards with update_form's blocks argument. For a Webflow-connected company, the form is saved but embed returns disabled plus the native Webflow settings path; custom embeds are not part of the Marketplace integration. With duplicateStrategy overwrite, submissions replace existing contacts' data; by default unsubscribed contacts who submit are resubscribed.
create_landing_page
ChatGPTCreate a draft landing page. Provide content for an exact page, or a template for generated starter content.
create_list
ChatGPTCreate a new subscriber list. Lists are public by default: public lists appear to subscribers in the email preference center, where they can join or leave them. Set isPrivate to keep the list internal.
create_non_opener_resend_draft
ChatGPTCreate a draft that resends a sent campaign to everyone in the same audience who didn't open it. Copies the campaign email and reuses the original audience with a 'didn't open this campaign' rule added. Only available 6 hours after the campaign finishes sending, and never for imported already-sent campaigns (Sequenzy has no opens for a send it did not deliver). The draft must be scheduled or sent separately. Returns the new draft and an estimate of how many subscribers haven't opened the original. Every audience format preserves hard opener exclusions, including earlier campaigns when resending a resend; manual additions cannot override them. Audience membership is live, so new members can qualify. Recreate older drafts missing excludedCampaignOpenerIds from the original campaign and review before scheduling.
create_push_campaign
ChatGPTCreate a push campaign draft. Content and audience can be set now or later with update_push_campaign; send with send_push_campaign.
create_segment
ChatGPTCreate a new segment from explicit filter rules. Use filters plus filterJoinOperator for flat legacy rules, or root for nested AND/OR groups such as { "kind": "group", "joinOperator": "and", "children": [{ "kind": "filter", "field": "attribute", "operator": "gte", "value": "mrr:50" }, { "kind": "group", "joinOperator": "or", "children": [{ "kind": "filter", "field": "tag", "operator": "contains", "value": "vip" }, { "kind": "filter", "field": "event", "operator": "is_not", "value": "saas.purchase:30d" }] }] }. AND of two or more positive attribute filters on the same array path (e.g. history_events[].eventvenue_id and history_events[].showing_date) requires one array element to satisfy every condition — a 2010 visit at that venue plus an unrelated recent booking elsewhere does not match. Negative filters (is_not, not_contains, is_empty) are exempt: they assert no element matches and combine independently. Supports event and segment fields, Stripe product purchase/current/trial/date filters, and campaign- or delivery-policy-scoped engagement filters such as emailOpened is marketing:all.
create_sequence
ChatGPTCreate and persist a disabled draft email sequence, follow-up series, drip campaign, nurture flow, or automation workflow. For natural-language content, provide goal and emailCount. Use explicit steps for finished caller-supplied content, exact workflows, or migrations. Configure trigger plus its relevant field, such as listId/listIds, tagName/tagNames, segmentId, or eventName. Supports email and SMS steps, delays and date waits, actions that dynamically create a provider discount/code (later emails print it with {{discount.code}}), subscriber updates, event filters, enrollment rules, sending windows, and stop conditions. The saved draft appears in list_sequences and stays disabled until enable_sequence is used for a user-requested activation. With goal, the AI email writer drafts the emails and can fetch URLs named in the goal and pages from the company's own website.
create_sequence_from_example
ChatGPTClone a public Sequenzy email gallery sequence into a draft sequence for this company, with the example's trigger family (signup, abandoned cart, order placed, or inactive tag) and send timing, up to 12 emails (the first 12 unless stepNumbers picks which; each kept email keeps its original timing from the trigger). AI then writes every email in the company's brand in the background (usually 30-60 seconds); poll get_sequence until enrichmentStatus is complete. If this tool returns enrichmentStatus not_queued with a warning, the draft exists but writing did not start: open it in the dashboard and do not call this tool again. The sequence stays a draft and sends nothing until enabled. Requires sequences:write. Each call creates another sequence. Accepts a gallery sequence URL (https://sequenzy.com/email-examples/brands/{brand}/sequences/{sequence}) or brand plus sequence slugs.
create_sequence_goal
ChatGPTCreate a persisted event, subscriber-attribute, or tag-applied conversion goal for one sequence. Event goals (the default triggerType) require triggerEventName; attribute_change goals require attributePath; tag_added goals require triggerTagName. This is distinct from create_sequence.goal, which is only an AI content prompt.
create_subscriber_import
ChatGPTQueue one CRM-grade subscriber import with up to 5,000 full contact records. Supports names, external IDs, phones, statuses, tags, lists, and custom attributes. Prefer this over repeated add_subscriber calls. Returns an import ID for get_subscriber_import. Use optInMode='confirmed' only when the contacts already gave verified email consent. duplicateStrategy overwrite replaces existing contacts' fields, and enrollInSequences or double opt-in can email imported contacts.
create_tag
ChatGPTCreate a new tag definition. The name is normalized to lowercase with hyphens (e.g. 'VIP Customer' becomes 'vip-customer'). Color defaults to gray.
create_template
ChatGPTCreate a new email template. prompt generates net-new email content from natural language. blocks is for finished caller-supplied Sequenzy content and html for supplied or explicitly requested preserved HTML. Creating a standalone copy of a saved design and AI rewriting within its layout are currently dashboard-only workflows; this tool has no source-design operation, and prompt does not preserve an existing layout. For a campaign copy, use create_campaign with templateId. With prompt, the AI email writer can fetch URLs named in the prompt and pages from the company's website to ground the draft.
create_template_from_example
ChatGPTRemix a public Sequenzy email gallery email into a new email template for this company. The new email keeps the example's exact layout and design; AI rewrites every piece of text for the company and its logo, brand color and links are swapped in. The example brand is never named and none of its copy, offers or claims are reused. Saved as an HTML template. Requires templates:write. Takes 5-20 seconds. Creates no template if generation fails (a company's first AI generation still saves its inferred email design direction); each successful call creates another template. Accepts a gallery email URL (https://sequenzy.com/email-examples/brands/{brand}/emails/{email}, or for an email in a sequence the sequence page URL ending in #email-{email}) or brand plus email slugs. For a whole sequence use create_sequence_from_example.
create_transactional_email
ChatGPTCreate a saved transactional email template with an API slug. prompt generates net-new content from natural language. blocks are finished caller-supplied Sequenzy content and html is preserved/imported markup. With prompt, the AI email writer can fetch URLs named in the prompt and pages from the company's own website.
create_warehouse_sync
ChatGPTSync contacts (kind subscribers) or events on existing contacts (kind events) from a warehouse query on a schedule. The mapping and cursor are checked against the query's real columns, and the first run starts right away. Each run only sends rows that changed since the last run. Imports overwrite existing contacts' mapped fields; triggerAutomations or double_opt_in can start sequences or send confirmation emails.
create_web_tracking_key
ChatGPTCreate a publishable key for the browser tracking SDK and return the install snippet. This is what turns on product views, cart activity, and browse abandonment for a site that is NOT Shopify or WooCommerce (custom storefronts, headless shops, marketplaces, SaaS marketing sites). Events start flowing once the snippet is deployed and nothing is backfilled for the period before that, so create and install it BEFORE building the sequence that depends on it. Always pass allowedOrigins: a key with none accepts anonymous events from any site. Identified events require a short-lived token minted by the customer's authenticated backend through POST /api/v1/web-tracking-identities (passing the key's publicKey or keyId), then sequenzy.identify(email, identityToken); a publishable key alone can never trigger subscriber automation.
delete_ab_test
ChatGPTPermanently delete a campaign A/B test and all of its variants. This cannot be undone. Running tests (testing or winner_selected) cannot be deleted, and the linked campaign must be in draft or rejected status.
delete_ab_test_variant
ChatGPTPermanently delete a variant from a draft campaign or sequence A/B test. This cannot be undone. Variant A is the control and cannot be deleted, and the test must keep at least the minimum number of variants. Variants cannot be removed after the test has started. Sequence tests whose parent sequence is active require confirmLiveChange. On an active sequence, contacts who reach the step afterwards no longer receive this variant.
delete_account
ChatGPTDelete an account and its memberships. Contacts are kept; their account.* attributes are cleared. Segment membership is re-evaluated, so running segment-entered or -exited sequences can email affected contacts.
delete_audience_sync
ChatGPTRemove an audience sync mapping. The Meta audience itself is kept (running ads are not disrupted) - only future syncs stop.
delete_campaign
ChatGPTPermanently delete a campaign. This cannot be undone. Sending, scheduled, or paused campaigns must be cancelled with cancel_campaign first. Deletion also disables the campaign's public share link if one exists.
delete_campaign_goal
ChatGPTDelete one persisted email-campaign conversion goal. SMS campaigns are not supported.
delete_data_export
ChatGPTDelete a data export. Sequenzy stops writing to the bucket; files already written are kept. Recreating it later starts from the time it is recreated. Also deletes the export's run history and stored credentials.
delete_email_component
ChatGPTDelete an email component. Emails that already rendered it keep their copied blocks, so this does not change existing emails. Deleting the component pinned as the default footer makes new emails fall back to the generated footer.
delete_in_app_message
ChatGPTDelete an in-app message or card so the app stops showing it. Deletion is permanent; the item cannot be restored to the contact's feed.
delete_landing_page
ChatGPTDelete a landing page. Published pages and pages with a connected domain are refused; deletion also removes the page's visit and conversion history.
delete_list
ChatGPTPermanently delete a subscriber list and remove all of its memberships. Subscribers themselves are kept. This cannot be undone. A public list disappears from the email preference center, and subscriber.list_unsubscribed webhooks fire for its active members.
delete_product
ChatGPTDelete a product previously pushed via upsert_products (Commerce API products only), identified by your productId.
delete_segment
ChatGPTPermanently delete a segment. This cannot be undone. Subscribers are not affected. Requires the segments:delete scope; segments:write is not enough. Segments that reference this one change who they match (an exclusion of it then matches everyone), and their running sequences can email the new matches.
delete_sender_profile
ChatGPTPermanently delete one sender (From) profile. This cannot be undone. Deletion is refused when this is the company's last sender or when a live campaign, active sequence (including a step-level override), or transactional email still uses it. Draft and rejected campaigns plus the account default are reassigned to the best remaining sender when needed; read fallbackSenderProfileId in the result and review that identity before sending. Reply-to profiles are not supported by this tool. Get the profile ID from list_sender_profiles. Requires the companies:manage scope. If it was the account default or used by code-managed transactional emails, later sends go out under the fallback From identity.
delete_sequence
ChatGPTDelete a sequence. Permanently deletes the sequence, its steps and every in-flight enrollment, even while it is active; there is no undo.
delete_sequence_goal
ChatGPTDelete one persisted sequence conversion goal.
delete_sequence_step
ChatGPTRemove one step from a sequence and join the steps before and after it. Contacts currently waiting at that step continue to the next step right away, or finish the sequence if there is none; the result shows how many moved on or finished. Edits are checked against graphRevision from get_sequence, so changes made in the meantime are never overwritten. For an active sequence, set confirmStructuralChange once the user approves the change. Released contacts can receive the next step's email immediately.
delete_subscriber_note
ChatGPTDelete one internal subscriber note by note ID.
delete_tag
ChatGPTPermanently delete a tag and remove it from all subscribers. This cannot be undone. System tags and tags used by sequences cannot be deleted. Segment membership is re-evaluated, so running segment-entered or -exited sequences can email affected contacts.
delete_template
ChatGPTDelete a template. Deletion is permanent and removes all localized variants; any public share link for the email stops working.
delete_transactional_email
ChatGPTPermanently delete a saved transactional email template by ID or slug. Use this to retire an obsolete template: the slug stops sending and becomes free to reuse. Already-sent deliveries and their stats are kept, so history and analytics survive the delete. The linked email content stays as a reusable template and comes back as deleted.emailId; pass that to delete_template to remove the content too. Code-managed emails (managedBy: code) are the exception: their content snapshot is deleted with them and deleted.emailDeleted is true. To stop sends without losing the template, call update_transactional_email with enabled set to false instead.
delete_warehouse_connection
ChatGPTDelete a warehouse connection and its stored credentials. Fails while syncs still use it.
delete_warehouse_sync
ChatGPTDelete a warehouse sync. Scheduled runs stop; contacts and events already imported stay. Also deletes the sync's run history and change-tracking state.
delete_web_tracking_key
ChatGPTPermanently delete a web tracking key. Cached authorization expires within one minute, after which requests from any remaining snippet are rejected; remove the snippet from the site as well. Prefer update_web_tracking_key with isActive: false when the key might be needed again.
delete_webhook
ChatGPTPermanently delete an outbound webhook endpoint along with its delivery history. This cannot be undone. To keep the endpoint but stop deliveries, use update_webhook with status disabled instead.
detect_account_organization_ids
ChatGPTFind the organization ID the app already sends, so accounts can be created from existing data without code. Looks at event properties from the last 180 days and contact attributes named like workspaceId, organization_id, team_id or account_id. Each candidate has source (event or attribute), propertyKey, nameKey (a sibling name property or null), eventCount (events for event, contacts for attribute), accountCount (distinct organizations) and eventNames. Read-only; next, preview a candidate with preview_accounts_from_organization_id and show it to the user.
disable_sequence
ChatGPTDisable/freeze a sequence. This blocks new enrollments and holds current recipients until the sequence is enabled again. To only stop new enrollments while current recipients continue, use pause_sequence_enrollments.
discard_campaign_variation
ChatGPTDiscard a campaign variation. It leaves the list and its branches move up to its parent; restore_campaign_variation undoes this.
discard_sequence_email_variation
ChatGPTDiscards a design variation of a sequence email, so it no longer lists. The email is unchanged.
disconnect_integration
ChatGPTDisconnect a Lemon Squeezy integration and stop live ingestion and sync. Deletes only the managed provider webhook; manual webhooks remain. Local disconnection succeeds even if provider cleanup fails: inspect cleanupWarning and repeat this call to retry cleanup. Other providers require the dashboard. Requires integrations:manage and owner/admin access.
duplicate_campaign
ChatGPTDuplicate a campaign as a new draft. mode 'campaign' (default) copies the campaign and its email, 'ab_test' also duplicates the campaign's A/B test with all variants, and 'variant' copies a single variant's content as the new campaign email (requires variantId).
duplicate_landing_page
ChatGPTDuplicate a landing page. The copy is created as a draft with its own slug and stats, so the original keeps its published URL.
duplicate_push_campaign
ChatGPTCopy a push campaign (content and audience) into a new draft.
duplicate_sequence
ChatGPTCreate an independent draft copy of a sequence, including its graph, email templates, and sequence A/B tests. The original is not changed.
duplicate_sequence_step
ChatGPTCopy an existing sequence step, for example to reuse an email, and place the copy right after or before another step. Each call adds one copy. Edits are checked against graphRevision from get_sequence, so changes made in the meantime are never overwritten. For an active sequence, set confirmStructuralChange once the user approves the change. On an active sequence, contacts that reach the copy receive its email or action in addition to the original.
edit_campaign_variation
ChatGPTChange one ready campaign variation with AI and save the result over it, like an edit in the editor: the prompt says what to change, in any language. With sectionIds only those top-level blocks change. A whole-variation edit may also give it its own emailTheme and fontFamily. Runs synchronously and can take up to a minute. Fails with 409 if the variation is not ready or changed while the AI was editing it, and with 400 when the AI changed nothing (the error explains why). Never changes the campaign email; use_campaign_variation does. The AI writer can fetch URLs named in the prompt and pages on the company's website.
edit_sequence_emails
ChatGPTChange a sequence's emails with AI in one request, like the Emails view in the sequence editor: the prompt says what to change, in any language ("make the background cream", "remove the header", "new structure for email 2"). Without emailIds the prompt decides which emails: every email, unless it names some. A look change (background, colors, fonts) is made identical across the emails it touches, down to each kind of block's style. "Make them all look like email 1" copies that email's style exactly without AI, keeping each email's words. For design variations of an email use generate_sequence_email_variations: such a prompt returns 400 here. An email written in HTML is edited as HTML and keeps its theme. A/B test steps, steps without an email and steps that send the same email as an earlier step are skipped and listed in skipped. Each email succeeds or fails on its own: emails[].status is changed, unchanged (summary says why) or failed; changed emails are saved (saved:true) unless dryRun is true. Saved changes apply to the next sends of an active sequence. Runs synchronously and can take up to a minute; one request edits up to 12 emails, so pass emailIds in batches for longer sequences. A 503 means the AI could not tell which emails the prompt means and nothing changed: retry or pass emailIds. An email saved elsewhere meanwhile comes back with saved:false and an error instead of being overwritten. If the call times out, read get_sequence before retrying: changes may already be saved. To set exact values instead of asking the AI, use update_sequence_nodes. The AI email writer can fetch URLs named in the prompt and pages from the company's own website.
enable_sequence
ChatGPTEnable/activate a sequence so it starts processing its triggers. Sequences are created disabled so their content can be reviewed before activation; this tool is intended for user-requested activation. simulate_sequence shows who currently matches and whether the sequence is ready. Activation does not enroll existing matches unless audienceAutoEnroll is saved. Relay any response warnings to the user, such as a contact_added trigger with no list, which enrolls every new contact. Matching contacts start receiving the sequence's emails, and contacts held while it was disabled resume from their current step.
enroll_sequence_audience
ChatGPTEnroll a whole audience (everyone, lists, a segment, a filter, or combined rules) into a sequence as a background run. Unlike enroll_subscribers_in_sequence there is no 500-contact cap: the worker walks the audience in batches, skips contacts already in the sequence (and, for one_time sequences, anyone who completed or was cancelled before), never enrolls unsubscribed or bounced contacts, and reports progress. This is how a manual-trigger countdown sequence (Black Friday) gets its audience: enable the sequence, then call this. Late enrollees skip the steps whose key date already passed. Pass data for run-level values that are the same for everyone in the run (a sale end time, a discount percentage); the sequence's emails read them as {{enrollment.FIELD}}. Defaults to dryRun, which only returns the estimate (matchingCount, alreadyEnrolledCount, enrollableCount); pass dryRun false to start the run and poll get_sequence_audience_enrollment. One run per sequence at a time. With dryRun false, enrolled contacts start receiving the sequence's emails and actions.
enroll_subscribers_in_sequence
ChatGPTManually enroll subscribers in a sequence by email address or subscriber ID. Maximum 500 total targets per call across emails and subscriberIds. Only active subscribers are enrolled: unknown emails are returned in notFound, while inactive, unavailable, and already actively enrolled subscribers are counted in skipped. By default enrollment starts at the first step after the trigger; pass targetNodeId to start at a specific step. Enrolled contacts start receiving the sequence's emails and actions from the first or targeted step.
estimate_push_campaign_recipients
ChatGPTCount how many contacts in an audience have an active push device (eligibleCount) versus the whole audience (audienceCount).
forward_conversation_message
ChatGPTEmail a copy of one received or sent message (with its stored attachments) to another address, such as a teammate. Notes cannot be forwarded. The forward is recorded in the conversation as a system message and does not change its status or unread state. Each successful call sends another copy, so after a timeout check the conversation with get_conversation before retrying.
generate_campaign_variation_section_options
ChatGPTGenerate 1-4 alternative versions of selected sections (top-level blocks) of the campaign email or of one ready variation. Saves no variation or email content (a company's first AI generation saves its inferred email design direction, like generate_email): each option has name, summary and replacements (new versions of the selected blocks with the same ids). Changes outside the selected sections are dropped, and options that change nothing are left out. Runs synchronously and can take up to a minute. Apply one with update_campaign_variation. The AI writer can fetch URLs named in the prompt and pages on the company's website.
generate_campaign_variations
ChatGPTVariations are alternative versions of a campaign's email, compared side by side on the editor's Canvas tab. They never change what the campaign sends until use_campaign_variation. Labels: V1, V2, ... for versions of the email, V2.1, V2.2, ... for branches of V2. Starts generating 1-4 variations with AI and returns them at once with status generating; it does not wait. Each takes its own direction planned from the prompt, so they differ; style sets how far they move. The source is the email's saved content, or parentVariationId (must be ready; the new ones are its branches). Poll list_campaign_variations or get_campaign_variation until each is ready or failed (usually under a minute). Variations succeed or fail independently; a retry is a new request that creates new variations. An email can have at most 8 generating at once; wait for them instead of retrying. The AI writer can fetch URLs named in the prompt and pages on the company's website.
generate_email
ChatGPTGenerate email blocks from a prompt. Returns a draft and does not create or send an email; the first generation for a company also saves its inferred email design direction, which later generations reuse. Generated blocks include the company's branding chrome (logo, footer with company name/address/unsubscribe) by default, matching emails created in the dashboard. The writer can fetch URLs named in the prompt and pages from the company's website to ground the draft.
generate_sequence
ChatGPT[DEPRECATED compatibility alias - use create_sequence] Create and persist a disabled AI-generated email sequence draft from a goal. The saved draft appears in list_sequences. The name defaults to the goal and the trigger defaults to contact_added; optionally pass listId to scope it. Review before enabling. The goal goes through the AI email writer, which can fetch URLs named in it and pages from the company's website.
generate_sequence_email_variations
ChatGPTDesign variations of a sequence email (see list_sequence_email_variations). Starts designing count (1 to 4, default 3) variations of the email as saved, from prompt ("a few bolder versions", "try other layouts"). Returns them at once with status generating; they finish in the background in about a minute. In MCP Apps clients it shows them as they finish. Refused for an email written in HTML (change it with edit_sequence_emails) and for A/B test steps. The AI writer can fetch URLs named in the prompt and pages from the company's own website.
generate_sms
ChatGPTGenerate SMS marketing message variants from a prompt. Nothing is created or sent; the first generation for a company also saves its inferred email design direction, which later generations reuse. Returns plain-text messages with per-message encoding and segment counts. Use the results as the 'text' of an SMS sequence step (insert_sequence_step with type 'sms' or a create_sequence sms step). Messages exclude opt-out footers and brand prefixes - the platform adds those automatically at send time.
generate_subject_lines
ChatGPTGenerate subject line variants for an A/B test from a prompt. Returns suggestions only and does not create or change a test; the first generation for a company also saves its inferred email design direction, which later generations reuse.
get_ab_test
ChatGPTGet A/B test details, variants, localization sync status, and settings. Sequence action_ab_test steps also expose each variant's blocks on get_sequence.sequence.emails[].abTest.variants; use this tool when you need the full test record rather than copy alone. Pass the abTestId from get_sequence.
get_ab_test_stats
ChatGPTGet A/B test aggregate stats, per-variant stats and whether the winner metric difference is statistically significant (95% confidence). Supports period or custom start/end ranges.
get_account
ChatGPTGet your own Sequenzy account: the companies (workspaces) you can access, which one is selected, and this connection's permission scopes. This is not your customers' B2B accounts; use list_accounts for those. Other tools use the selected company unless a companyId is passed, and select_company changes the selection. Use it when the user asks which companies they can access, or after a missing-permission error to see what this connection can do.
get_account_by_external_id
ChatGPTGet one account by its external ID, including up to 100 members with their roles (owner, admin, member).
get_account_health
ChatGPTRead the company's account health report: what to fix in its email setup. Returns eligibility (checks need more than 1,000 active subscribers and an email sent in the last 14 days; hasMinimumSubscribers and sentRecently say which is missing), settings (enabled, autonomy), nextRunAt, the latest run (status, AI summary, stats snapshot of this period vs the one before) and runInProgress, plus open and snoozed insights, most severe first. Each insight has a detector (unhandled_event, stalled_sequence, campaign_gap, stale_campaign_drafts, underperforming_sequence_email, deliverability_spike, sending_domain_failing, missing_sequence: a standard lifecycle sequence such as welcome or re-engagement the workspace does not run yet, with the suggested playbook, name, goal, trigger and steps in evidence; over_emailing: people who got 4+ marketing emails within 24 hours in the last 7 days, with overloadedSubscribers, recipients, peakPerDay, frequencyCap and the campaigns, sequences and marketing Send API email (type api, which the cap does not limit) behind it as sources in evidence; neglected_subscribers: active subscribers who got no marketing email in 90 days, with neglectedSubscribers, eligibleSubscribers and estimated in evidence), severity, title, detail, recommendation fixAutomationId when the agent drafted an inactive sequence to fix it, and actions: what to do about it, primary first. Each action has kind (create_sequence, open_sequence, activate_sequence, pause_sequence, create_campaign, review_campaign_drafts, open_campaign, verify_sending_domain, open_domain_settings, review_deliverability, open_frequency_cap_settings, apply_frequency_cap), label, targetId, a dashboard path for screens, a confirm prompt for changes to live sending, and the api call that performs it: create_sequence -> create_account_health_fix, activate_sequence -> enable_sequence, pause_sequence -> disable_sequence, verify_sending_domain -> verify_sending_domain, open_frequency_cap_settings -> set_frequency_cap (for example maxEmails 1, windowHours 16) when evidence.frequencyCap is null, otherwise get_frequency_cap and only tighten it (the cap only holds back sequences, so when the sources are only campaigns or api it does not help; suggest spacing those out instead), apply_frequency_cap -> update_sequence with frequencyCapEnabled true on targetId; the others open dashboard screens. Each insight also has feedback: the connected user's own answer from submit_account_health_feedback ({rating, comment, updatedAt}), or null. Confirm with the user before set_frequency_cap or apply_frequency_cap. Confirm with the user before activate_sequence or pause_sequence. Requires analytics:read.
get_account_organization_id_job
ChatGPTCheck a create_accounts_from_organization_id run. state is queued, running, completed or failed. A completed job has result with accountsCreated, accountsUpdated, membershipsCreated, membershipsUpdated, skipped and truncated (history was larger than one run covers; start it again to continue). A failed job has error. Finished jobs expire after a while (404); the accounts stay.
get_app_urls
ChatGPTGenerate Sequenzy dashboard URLs for known resource IDs. Use this when the user asks where to review or edit a generated sequence, campaign, template, or company settings. If companyId is omitted, the selected/current company is used when available.
get_attio_mapping
ChatGPTInspect a connected Attio integration's list mapping: every Sequenzy list, every Attio people-list the stored token can write (id, api slug, name), the saved listMap, mappedListCount, and whether company matching from work-email domains is on. Use it when Attio is connected but mappedListCount is 0, and call it before update_attio_settings so you have Attio list ids or slugs instead of asking the user to paste UUIDs. Reads Attio live on every call. Credentials are never returned. Attio only; other providers return a clear error. Check get_integration first — availableActions includes update_attio_settings when mapping can be saved without reconnecting.
get_campaign
ChatGPTGet campaign details and stats, including rejectionComment reviewer feedback for rejected campaigns. emailId is the campaign's linked email body - the same record returned by the templates tools - and can be passed as templateId to create_campaign to reuse the design; it is null for SMS campaigns. emailPreset reports that email's Style > Format the same way get_sequence does per step (branded or minimal; null for SMS campaigns and standalone raw HTML emails), so campaign chrome can be compared against sequence steps and transactional templates without rendering them - minimal suppresses the company logo at render time. targetLists holds the raw audience targeting (IDs only); call get_campaign_audience for resolved list/segment names and a recipient count. Note that computedLists is email personalization (product lists rendered inside the email), not audience targeting. For native sends, sentAt is stamped when the last recipient is handed off, so on a paced send it is the end of the delivery window; spreadOverHours, sendTimeOptimization, and sendTimeWindowHours report recorded pacing, and maxRecipients reports the recipient cap (null = whole audience). Change draft pacing or the cap with update_campaign, or apply them when calling schedule_campaign. Send Time Optimization is not a company or sequence setting. It is campaign-only: audit with list_campaigns or get_campaign (sendTimeOptimization, sendTimeWindowHours, default 12h window). Change a draft with update_campaign, or apply it when calling schedule_campaign. Sequences use sendingWindow (allowed local hours/days), which is a shared gate, not per-subscriber predicted send times. Imported campaigns may not include pacing metadata from their source provider, so absent pacing fields do not prove that delivery happened all at once.
get_campaign_audience
ChatGPTResolve exactly who a campaign will reach. Returns the targeting kind, resolved list and segment names (flagging references that no longer exist), filter conditions, individual include/exclude adjustments, a plain-language summary, and a live recipient count. Critically, it reports whether targeting is unset - an unset campaign falls back to every active subscriber when scheduled. Use this to verify a scheduled campaign's audience before it sends. This is a read-only resolved view, not the write shape: to change targeting, pass targetLists (e.g. {type:'lists', listIds:['list_123']}) or the segmentId/listIds shorthands to update_campaign or schedule_campaign.
get_campaign_stats
ChatGPTGet detailed statistics for a campaign, including replies and reply rate, attributed conversions, revenue (revenueCents), attached campaign conversion goals in the top-level goals array (sent → opened → clicked → each named goal), product recommendation funnel metrics, a per-link click breakdown in the top-level clickedLinks array, and any Poll or NPS survey summaries in the top-level polls array.
get_campaign_variation
ChatGPTGet one campaign variation, including its status while it generates and its blocks once ready. Discarded variations are not found.
get_company
ChatGPTGet company details, processing status, product info, brand colors, AI writing context, the default AI email style (emailStylePreference: visual, plain, or null when not chosen) and header and footer (emailPreset), reply-tracking settings, effective email localization settings, and the read-only emailBranding entitlement. emailBranding says whether the "Sent with Sequenzy" footer is visible on this company's emails and why. Branding is injected at render/send time rather than stored in footer blocks. Also returns defaultSubscriberListIds - the workspace default lists new contacts join when nothing targets them explicitly. A JSON null means every current and future list, not an empty selection; [] means no list at all; an array means exactly those lists. Change it with update_company. Read it before connecting an integration whose provider has no per-integration list targeting (Dodo Payments, PostHog, Polar, Paddle, and similar), because its live contacts and payment-provider backfills land there. PostHog history imports are different: contacts created by that import have no list memberships. Send Time Optimization is not a company or sequence setting. It is campaign-only: audit with list_campaigns or get_campaign (sendTimeOptimization, sendTimeWindowHours, default 12h window). Change a draft with update_campaign, or apply it when calling schedule_campaign. Sequences use sendingWindow (allowed local hours/days), which is a shared gate, not per-subscriber predicted send times.
get_conversation
ChatGPTGet a conversation with its full message history, subscriber details, and context. Message attachments include a downloadUrl (signed, valid for one hour) when the file is stored.
get_data_export
ChatGPTGet one data export with its status, per-dataset progress (exportedThrough), next run and last error.
get_default_email_component
ChatGPTGet the company's default component for a slot - use this to read the current email footer before editing it. Returns not_found when no default is set, which means emails fall back to the footer Sequenzy generates from the company profile.
get_design_md
ChatGPTGet the company's design.md: its email design brief as one Markdown document. YAML frontmatter holds the exact values Sequenzy applies when rendering AI-generated emails (logo, colors, fonts.body/heading, buttons.style/radius, cornerRadius, layout tokens); prose sections hold the Voice and the Design direction the AI writer follows, plus a read-only Reference email naming the saved AI style. Values shown are the ones emails actually get. Returns markdown, version (pass it to update_design_md as expectedVersion), and the parsed designSystem. Read this before writing or redesigning emails for the company.
get_email_ai_style
ChatGPTGet the company's saved AI email appearance, revisionId and canManage. Read this before replacing or clearing a style. No active style returns null; an unsupported version can still have a revisionId for recovery.
get_email_block_schema
ChatGPTField reference for Sequenzy email blocks: which fields each block type requires, which are optional, the allowed values of every enum field, and the shape of nested item arrays and nested objects. Call this before authoring blocks for a type you have not written before, or after a block write is rejected. The blocks parameter on create_campaign, create_sequence, create_template, and update_sequence_node accepts any of these types, but is declared as a plain object array because the union is too large to inline. Without a blockType this lists every type with its required and optional fields; with one it returns that type's full reference plus a minimal valid example and authoring notes. group is a persisted structural type managed by the editor and is omitted by creatableOnly; request it by name when reading existing grouped content. Note that lists are their own block type rather than a text variant: a numbered list is {"type":"list","variant":"numbered","items":[{"content":"First"}]}, and a visual numbered walkthrough is {"type":"steps","variant":"numbered","items":[{"title":"Step one","description":"What happens"},{"title":"Step two","description":"What happens next"}]}. A text block only accepts variants paragraph, lead, and html, and never accepts items. Every block also takes a conditions array, and each condition field accepts only its own operators - a block's own field and operator enums pool every field's operators together, so they list is for tag even though a tag condition is rejected with it. The conditionFields table resolves that: the operators each condition field accepts, how its value string is shaped, and what render_email needs before it can evaluate the condition rather than rendering it as false. It comes back automatically when you list every type and when you ask for conditional-group; on any other single type pass conditionFields: true, since the table is several times the size of one block's reference.
get_email_client_stats
ChatGPTGet which mail clients (Apple Mail, Gmail, Outlook, Yahoo Mail, Thunderbird, Android mail app, web browser, other) and device types (desktop, mobile, tablet, unknown) opened your emails, as shares of unique opens. Pass campaignId for one campaign (all time); omit it for the whole company over period or start/end (default 90d) with an optional emailType. Each email send counts once, attributed to the client of its first open. Gmail, Yahoo and Apple Mail Privacy Protection fetch images through proxies, so those opens report the client with an unknown device; privacyProxyOpens counts them. Report shares, not absolute reach: recipients who never open are not represented. New Outlook for Windows and Outlook.com count as web_browser, and some WebKit apps such as Outlook for Mac count as apple_mail.
get_email_component
ChatGPTGet one email component's blocks and metadata by id, including its version and whether it is pinned as a company default slot.
get_email_design_system
ChatGPTGet the company's email design system: the visual identity every AI-generated email (campaigns and sequence steps) renders inside - design code (kicker style, title alignment, button shape, divider style, density, sanctioned opener treatments) plus the composition spine (hero-led | editorial | product-spec) that anchors email structure. The identity is stored as the company's emailDesignPrompt direction text; this tool returns the structured tokens parsed from that text (falling back to brand derivation per unstated token), the raw directionText, and isDefault (true while the identity is still purely derived from brand context).
get_email_send
ChatGPTGet an email delivery by emailSendId, including queued and test sends, delivery status, provider failure reason, stored HTML, effective Reply-To, copied-recipient identity and primary email send ID, and the ClickHouse event timeline. type is the legacy source category; use emailType on the send and deliveryPolicy on events for the actual marketing or transactional policy when known. Queue jobs are internal execution details and are not exposed.
get_event_sample
ChatGPTRead the latest actual received event in the selected workspace, across all subscribers. Requires subscribers:read. Returns sample: null when none exists. Copy sample.properties into start_sequence_test_run customVariables, editing as needed. This read does not fire an event or change the selected test recipient. Unlike get_event_schema, this is recorded account data, with no age cutoff.
get_event_schema
ChatGPTRead the published payload of a built-in event: a real example payload per provider, plus every property path with its type, the merge tag that resolves it, and a note wherever the example alone is ambiguous. Call this BEFORE writing {{event.*}} merge tags or event property filters - an unrecognized merge tag renders as an empty string rather than an error, so a guessed property name ships silently broken. It is also the only place that spells out the traps the sample cannot: money fields ending in Cents are minor units while predictedLtv is whole currency units, price is a preformatted display string that must not be parsed, churnRisk is a 0-95 percent and not a probability, and orderId is a string on Shopify but a number on WooCommerce. Omit eventName to list every documented event, or pass provider to get one provider's payload instead of all of them. Custom events are first-class and deliberately absent from this list: documented: false means no sample is published, never that the event name is invalid or will be rejected. Static reference data - it describes the event shape, not what this account has received. Use get_event_sample to read the latest actual received payload.
get_form_embed
ChatGPTGet a published saved form's action URL, one-line JavaScript embed, minimal native form action, and fetch example. Use this for Astro, Hugo, Jekyll, Cloudflare Pages, Netlify, GitHub Pages, or other non-Webflow browser integrations. For a Webflow-connected company, returns embed.disabled plus the native Webflow settings path and no custom code.
get_frequency_cap
ChatGPTGet the company frequency cap: the most marketing emails (campaigns plus marketing sequence emails) one contact may receive in a rolling window. frequencyCap is null when no cap is set. Only sequences with frequencyCapEnabled respect it: their email steps are skipped for a contact already at the cap, and the contact moves to the next step. Campaigns count toward the cap but always send. Transactional emails never count and are never skipped.
get_in_app_step_stats
ChatGPTCreated, displayed, clicked and dismissed counts for one in-app sequence step.
get_inbox_address
ChatGPTGet the email address anyone (a person, a service, or another agent) can write to so the message lands in this company's Sequenzy inbox. Also returns the default address, the branded address (customAddress, with status active or pending), whether receiving is on, whether attachments are stored, and how many days messages are kept. Replies to Sequenzy emails arrive in the same inbox automatically.
get_integration
ChatGPTInspect one connected integration in depth: what the provider syncs, every event it can emit and when, every matching tag rule, which sequences trigger on those events, recent integration-specific activity, and prioritized recommendations. For Webflow, webflowCapture reports the exact selected native forms, retained field names, double-opt-in policy, list IDs, sequence toggle, webhook status, and schema fetch time; capture is off when its forms array is empty. observedByAccount and accountLastSeenAt are account-wide because event definitions can also be updated by another integration or the public events API; use the retained activity log for connection-specific delivery diagnosis. For Attio, details.mappedListCount 0 and an attio_lists_unmapped recommendation mean list joins are not synced — use get_attio_mapping then update_attio_settings; do not reconnect for that. Read-only; credentials are never returned. Get the id from list_integrations. For Shopify and Attio integrations it reads the store's pixel state and the Attio list catalog live from those providers' APIs.
get_integration_guide
ChatGPTGet code examples for integrating Sequenzy into your project. SaaS and subscription apps: when the app uses Stripe, Polar, Paddle, Dodo, Lemon Squeezy, or Creem, the native integration in the Sequenzy dashboard (Settings -> Integrations) handles payment events and customer tags automatically, so no code is needed for those. E-commerce stores: Shopify and WooCommerce stores use the native integration in the dashboard, which syncs products, orders, and customers automatically. Other e-commerce stacks (custom checkouts, CheckoutChamp, Sticky.io, headless storefronts) integrate through the 'ecommerce' use case and the Commerce API. Manual event tracking code is an opt-in use case for custom events only. Use cases: - 'transactional': Sending one-off emails (welcome, password reset, receipts) - 'subscribe_form': Adding subscribers from signup forms - 'event_tracking': Tracking CUSTOM events only (not payment events - those come from the integration) - 'ecommerce': Connecting a custom e-commerce platform via the Commerce API (sync products, push orders/checkouts, power abandoned cart + back-in-stock automations) Protected server-side API work needs a Sequenzy API key, passed to the SDK as apiKey: process.env.SEQUENZY_API_KEY. Non-Webflow static-site saved forms are the exception: list_forms/create_form/get_form_embed return public embed code, and secret keys must never be placed in browser code. Webflow-connected companies use explicitly selected native forms in Settings -> Integrations -> Webflow; custom embed code is disabled.
get_integration_pixel
ChatGPTCheck whether a Shopify store's storefront tracking pixel is installed and reporting to this account. Read live from Shopify on every call, because a merchant can remove the pixel without Sequenzy hearing about it. Check this before telling the user that browse abandonment, cart recovery, product views, collection views, or storefront search will work: without a live pixel those events never arrive, the sequences built on them never fire, and nothing anywhere reports an error. Returns pixel.healthy, the endpoint and signed configuration state, and dependentEvents - the event names that rely on this pixel. When pixel.error is null and pixel.healthy is false, those events are confirmed dark; an error means Shopify could not confirm their state. Fix a confirmed unhealthy state with activate_integration_pixel. Shopify only; other providers return a clear error.
get_landing_page
ChatGPTGet landing page details, content, metrics, and URLs. Drafts have publicUrl and appPublicUrl set to null; previewUrl is a signed, unlisted visitor-facing preview that works before publish. Use render_landing_page when you need that preview URL called out with publish-vs-draft guidance. viewCount and conversionCount are lifetime totals; use get_landing_page_stats for unique visits, referrers, a date histogram, and whether crawlers were counted.
get_landing_page_stats
ChatGPTGet landing page analytics: visits, unique visits, clicks, subscribes, conversion rate, a daily histogram, referrers, and UTM sources. Default counts exclude known crawlers; preview URLs and the editor are never counted. Opening the public URL while building the page does count. Pass includeBots to include crawler hits in visits. period defaults to all retained events with a 90-day histogram; dataAvailableFrom identifies the beginning of retained coverage, which may be later than the page's lifetime counters.
get_link_click_stats
ChatGPTGet clicks per link destination across every email in the company over period or start/end (default 90d), ranked by unique clicks, with an optional emailType. Destinations ignore query strings, fragments and trailing slashes, so the same page linked with different UTM tags counts as one link. Each link reports clicks (every click, repeats included), uniqueClicks (subscribers who clicked it, each counted once) and share (percentage of totalUniqueClicks). totalClicks, totalUniqueClicks and totalLinks cover every destination before limit. For one campaign's links, read clickedLinks from get_campaign_stats instead.
get_notification_preferences
ChatGPTGet the account notification settings for the connected user in this company: whether Sequenzy emails them when a new subscriber joins, when a form is submitted, when a campaign finishes sending, and whether they get the Monday weekly report (last week's sends, engagement, new subscribers, revenue, goals, and sequence trends versus the week before; on by default for the workspace owner, off by default for invited members, only sent for weeks with more than 10 emails sent), whether they get the account health check's findings (account_health: on by default for the owner, opt-in for members; carried inside the Monday report when they get it, otherwise sent as their own email), and whether each arrives per-occurrence, as a daily summary, or weekly. Instant form-submission notifications stop after 50 per workspace per UTC day. Returns the supported modes and the platform defaults for this user's role alongside the current values. These are per-person settings - this never reads a teammate's preferences.
get_push_campaign
ChatGPTGet a push campaign's content, audience, status and (after sending) delivery stats.
get_push_campaign_stats
ChatGPTGet push campaign delivery stats: sent, displayed (device-reported), clicked, failed and skipped contacts, devices targeted/accepted, and skip/failure reasons.
get_push_settings
ChatGPTGet push notification readiness: whether web push is enabled (with its VAPID public key), whether APNs (iOS) and Firebase (Android) credentials are connected, the last credential error for each, and active device counts per platform. Check this before creating push campaigns or push sequence steps.
get_receiving_domain
ChatGPTGet one receiving domain: status, DNS records to publish, error, and claimExpiresAt.
get_recipient_suppression
ChatGPTCheck whether one recipient is suppressed by Sequenzy's bounce/complaint safeguards. Suppression comes solely from Sequenzy's own bounce records; the email provider's suppression list is not consulted. This exact-address lookup never exposes other recipients.
get_segment_count
ChatGPTGet the number of subscribers in a segment.
get_sending_domain
ChatGPTRead a sending domain's separate DNS verification and sending readiness. Use verify_sending_domain to run a fresh check. dnsUpgrade.status: available (see upgrade_sending_domain_dns), in_progress (records to add), completed (oldRecords to delete) or unavailable. Receiving mail (inbox addresses and replies) is set up on receiving domains instead: see list_receiving_domains.
get_sending_status
ChatGPTCheck whether company-level email sending is active, paused, or suspended, and what it takes to restore it. Relevant whenever a send, test send, or sequence step fails for a reason that is not a validation error, and whenever the account reports a bounce or complaint rate problem. Returns the pause reason and reason kind, when it was paused, the automated sender-health review state, whether the one-click resume is currently available (and if not, which gate is blocking it), the enforcement counts and thresholds for permanent bounces, temporary bounces, and complaints, and ordered remediation steps. There is no rolling window and no expiry. Enforcement uses all-time totals counted from a reset watermark, so a paused rate does NOT decay over time. Waiting does not restore sending. The rate only changes as real (non-test) sends accumulate or when a resume moves the watermark. metricsWindow contains the exact watermark timestamps. Requires the account:read scope, so a read-only key can diagnose a blocked account. resume_sending restores sending once the underlying problem is fixed.
get_sequence
ChatGPTGet sequence details, editable step content, and graph topology. Read effectiveStatus (draft, live, enrollment_paused, paused, archived) to know whether a sequence is running: status alone reads active even when new enrollments are paused, and the legacy triggerConfig.active flag is not used by the runtime. Each sequence.nodes item includes id, nodeType, current config, updatedAt, and updateHints with its editable/managed fields and ready-to-return expectedUpdatedAt token for update_sequence_node/update_sequence_nodes. The response also includes sequence.edges and graphRevision for safe edit_sequence_graph calls, plus sequence.emails with each email step's nodeId, nodeType, linked emailId, subject, previewText, emailPreset (the per-email Style > Format for native blocks, including emails with supported custom HTML blocks; null when the entire email is standalone raw HTML), and blocks. sequence.emails includes action_ab_test steps, whose copy lives on the A/B test variants rather than on the node: their subject/previewText/blocks are control variant A only. With ab_tests:read, each carries abTest with the test id, status, and one entry per variant including that variant's full blocks, so a sequence read is enough to audit CTA/promo/review copy; without that scope, test-record fields are redacted and variants is empty while the configured id and editing guidance remain available. To change the copy of an A/B step, edit each variant with update_ab_test_variant; do not write through update_template or update_sequence_node. Rebuilding the step as a plain email node to reach the copy destroys the test. get_ab_test remains the dedicated A/B read for settings, localization, and stats. Send Time Optimization is not a company or sequence setting. It is campaign-only: audit with list_campaigns or get_campaign (sendTimeOptimization, sendTimeWindowHours, default 12h window). Change a draft with update_campaign, or apply it when calling schedule_campaign. Sequences use sendingWindow (allowed local hours/days), which is a shared gate, not per-subscriber predicted send times.
get_sequence_audience_enrollment
ChatGPTStatus and counters of one audience enrollment run started with enroll_sequence_audience. Poll while status is queued or running.
get_sequence_enrollment
ChatGPTRead one sequence enrollment token, including how it entered and which branches it already took. Use this after list_sequence_enrollments when a completed token shows enteredVia unknown or Sequence completed with no email: nodeHistory is the bounded ClickHouse graph walk (redacted), and nodeHistoryTruncated tells you when more events exist. branchDecisionCount and branchDecisionsTruncated report whether the token's bounded decision array omitted older decisions. A legacy token whose first unmatched branch went straight to completion still reports the compared field name and a safe value summary (missing/empty/nonempty/equals_expected) rather than the raw recipient value. entryContext lists event property keys, never values. Requires sequences:read.
get_sequence_enrollment_realignment
ChatGPTCheck a queued sequence enrollment realignment. Call this with the jobId returned by realign_sequence_enrollments after applying with dryRun false. When status is completed, result contains the realignment counts, sample, and any nextCursor needed for another bounded apply call.
get_sequence_inbound_webhook
ChatGPTRead the non-secret mapping, sample payload, setup status, and dashboard URL for a sequence inbound webhook. The credential-bearing endpoint URL is omitted here.
get_sequence_stats
ChatGPTGet statistics for a sequence. The steps array is the per-step breakdown: one entry per email step in graph order with its step number, automation nodeId, subject, and its own sent, delivered, bounced, opened, clicked, replies, and unsubscribed counts plus rates - so this is where you read how many of Email 4 went out, without reconstructing anything from list_sequence_events. Step counts come from the retained event stream, not the 14-day delivery history behind list_email_sends, so they stay answerable for old sends. Also returns the aggregate funnel across every step, attributed conversions and revenue (revenueCents), product recommendation funnel metrics, per-step failed subscribers and failure reasons, and enrollmentSkipped counts for trigger matches where the contact could not be enrolled (unsubscribed/bounced). Pass period or start/end to use one explicit window for every historical metric; without them, step and aggregate counts are all-time and enrollmentSkipped defaults to the last 30 days. The enrollmentCounts field is a live snapshot of active and waiting enrollments grouped by current node, so it is not limited by period or start/end. To compare the same step across many sequences in one call, use list_email_metrics instead.
get_sequence_test_run
ChatGPTRead live sequence test status, recipient, timestamps, step logs and errorMessage. Requires sequences:read and subscribers:read. Inspect failed runs before retrying because completed actions are not rolled back.
get_shopify_automation_settings
ChatGPTGet the connected Shopify store's automation settings: browse abandonment (emails shoppers who viewed a product but didn't buy), cart abandonment (fires ecommerce.cart_abandoned with the full cart after the cart sits inactive), and price drop alerts (emails recent viewers when a product's price falls). Returns the effective values with platform defaults applied.
get_sms_settings
ChatGPTGet the company's SMS add-on status: whether SMS is enabled, plan eligibility, credit balance, brand prefix, phone numbers (each with linkShorteningEnabled), and whether SMS steps will actually send. Check this before adding SMS steps to sequences so you can warn the user when SMS is not ready.
get_sms_usage
ChatGPTGet per-number SMS usage for the company: sends, delivered, failed, credits charged, last-sent time, and test-send count for each phone number the workspace has sent from. Use it to compare how the workspace's numbers are performing or to check what a number was used for before releasing it.
get_stats
ChatGPTGet overview statistics for a time period, including reply count and reply rate. Counts form a funnel over the sends made inside the period: opened and clicked are unique per email send (not total open events) and include engagement that arrives after the period ends, so they never exceed sent. Rates divide by rateDenominator (delivered, falling back to sent), reported alongside rateDenominatorBasis. Set emailType to transactional for Send API and transactional SMTP open/click rates, including both direct and saved-template sends. Also returns top-level subscriberCount (every stored contact) and activeSubscriberCount (status=active) as a live audience snapshot, independent of period; use these for 'how many subscribers do I have' instead of search_subscribers pagination.total. When no emailType filter is used and a background-computed snapshot is available, the response also includes a top-level commerceForecast with predicted AOV, 12-month customer value, 90-day revenue, confidence, and data-eligibility reasons.
get_subscriber
ChatGPTGet the full subscriber profile, including tags, notes, list memberships, sequence enrollments, email stats, and recent activity. For commerce customers, customAttributes include nightly predictive analytics: predictedLtv (next-12-month spend), churnRisk (percent), expectedNextOrderAt, avgDaysBetweenOrders, and predictionConfidence.
get_subscriber_activity
ChatGPTGet recent activity, email stats, and current sequence enrollments for a subscriber.
get_subscriber_import
ChatGPTGet progress, counts, skipped reasons, and failure summaries for a queued subscriber import. Every excluded row is explained: skippedReasons sums to skippedCount and failedReasons sums to failedCount, so a finished import can be reconciled without inspecting individual contacts. If the reason counts fall short of the totals, report it with the import ID rather than guessing what the missing rows were.
get_subscriber_operation
ChatGPTRead background operation progress and state. A completed tagging operation may have per-contact failures; inspect failed and failures.
get_sync_rules
ChatGPTGet the company's sync rules: the automatic tag changes applied when events fire (e.g. order placed -> add a tag). New companies start with no rules. Returns the effective rules plus isDefault, which is true when the company has explicitly opted into the inherited SaaS/ecommerce platform preset.
get_template
ChatGPTGet a template's details, content, and all localized variants with sync status. emailPreset reports the per-email Style > Format (branded or minimal; null when the whole email is standalone raw HTML) the same way get_sequence does per step.
get_tracking_domain
ChatGPTGet the company tracking domain every sending domain uses for tracked links and opens: hostname, status, whether links use it now (active), the CNAME record to publish, and the last check. trackingDomain is null when none is set and links use the shared Sequenzy domain.
get_tracking_settings
ChatGPTGet the company's email tracking and signup consent configuration: account-wide and Transactional API open/click defaults, unsubscribe tracking, opt-in strict bot filtering, default attribution window, automatic UTM tagging, the company tracking domain (shared by every sending domain) and its verification status, inbound reply-tracking settings, and whether double opt-in is required for new contacts. Use this to audit measurement readiness, to explain why opens or clicks may not be recorded, and to check how contacts enter the list before investigating bot or alias signups.
get_transactional_email
ChatGPTGet a transactional email by ID or slug, including subject, preview text, blocks, variables, and linked dashboard URLs. emailPreset reports the per-email Style > Format the same way get_sequence does per step (branded or minimal; null when the whole email is standalone raw HTML), so it can be compared against sequence steps and campaigns without rendering them - minimal suppresses the company logo at render time.
get_transactional_stats
ChatGPTGet aggregate sends, deliveries, bounces, opens, clicks, and rates for one saved transactional email selected by ID or slug. Results are all-time by default; pass period or start/end for a window. For direct-content Send API messages, use get_stats with emailType transactional and list_email_sends/get_email_send for delivery-level detail.
get_warehouse_connection
ChatGPTGet one warehouse connection with its settings, status, last test and number of syncs. Credentials are never returned.
get_warehouse_sync
ChatGPTGet one warehouse sync with its status and latest run.
get_web_tracking_key
ChatGPTGet one web tracking key with its install snippet and ingest endpoint. Use this to hand a developer the exact <script> tag to paste, rather than reconstructing it - the snippet embeds both the publishable key and the workspace id, and a hand-built one that gets either wrong fails silently.
import_subscriber_events
ChatGPTRecord a bounded batch of events for many subscribers in one call, built for data pipeline and warehouse syncs. Each event carries its own email or externalId and a required source-owned eventId; externalId-only rows must identify an existing contact because email is required for creation. Contacts whose events are all more than an hour old are imported silently as history (including no double-opt-in email); any recent event makes that contact's whole group live. Retries keep one receipt and re-attempt any downstream recovery that has not finished. Accepts at most 25 events. Contacts with recent events run sequence triggers and sync rules, which can email them.
insert_sequence_step
ChatGPTInsert one dashboard-compatible typed step into an existing sequence: email, SMS, delay/date wait, discount (later emails print the generated code with {{discount.code}}), subscriber update, tag/list action, outbound webhook, AI step (later steps use the generated text with {{ai.KEY.field}}), condition gate, wait-for-event, or wired If/Else branch. Use get_sequence first and pass afterNodeId. Branch paths can target existing nodes, including completion. To nest a branch inside a branch path, end that path with the step the nested branch should follow, then call insert_sequence_step again with type 'logic_branch' and afterNodeId set to that path node - addedBranchPathNodeIds in the response lists each path's node IDs in order, and the nested paths reconnect to the shared steps that already followed it. A logic_branch with splitMode 'random' plus randomPercentages is a weighted split rather than an If/Else, so it runs a concurrent A/B test inside the flow - use it to compare two offers in the same abandoned-cart sequence instead of running duplicate sequences one after another. To A/B test the content of one existing email step and have a winner picked automatically, use create_ab_test with automationNodeId instead. For active sequences, confirm the structural change first. On an active sequence, contacts reaching the new step receive it; webhook steps post to external URLs, discount steps create Stripe or Shopify codes, and AI steps call a language model.
invite_team_member
ChatGPTInvite a team member by email with role admin, marketer, viewer, or restricted. Existing Sequenzy users are added to the team immediately; others receive an email invitation. Billing access (canManageBilling) can only be granted by the company owner and is not available for marketer or restricted members. Calling it again for an address whose invitation expired or was cancelled reissues it with a new link and emails it again; a still-valid pending invitation returns 409. Existing Sequenzy users gain access at once with no acceptance step; reissuing an expired or cancelled invitation replaces its link.
list_ab_tests
ChatGPTList A/B tests and their variants.
list_account_events
ChatGPTList recent events on an account's timeline, newest first.
list_account_members
ChatGPTList the member contacts of one of your customers' accounts (a B2B organization such as a company, workspace or team, identified by your own externalId), with each member's role: owners first, then admins, then members. These are not the members of your Sequenzy workspace. Read-only.
list_account_suggestions
ChatGPTSuggest accounts from work email domains that several contacts share (for example 7 contacts at acme.com). Personal and disposable providers (gmail.com, outlook.com, yopmail.com, ...), the workspace's own sending domains, domains where any contact already belongs to an account, and domains an account already uses are skipped. Each suggestion includes up to 10 sampleEmails for review. Read-only; show the list to the user and accept only the domains they confirm with accept_account_suggestions.
list_accounts
ChatGPTList your customers' accounts (B2B organizations such as companies, workspaces or teams) in the workspace. Not your Sequenzy account: use get_account for that. Search matches name, external ID and domain. Accounts group contacts; their attributes fan out to every member as account.<name> for segments and {{account.<name>}} merge tags.
list_ad_accounts
ChatGPTList the Meta ad accounts available through the connected Meta Ads integration. Use the returned account id as adAccountId when creating an audience sync. Fetched live from Meta through the Zernio ads API on each call.
list_audience_syncs
ChatGPTList Meta custom audience syncs (segment -> ad audience mappings) with their schedule and last sync status. Requires the Meta Ads integration to be connected in the dashboard.
list_campaign_events
ChatGPTList paginated raw email events for a campaign. Defaults to deliveries; use eventType or eventTypes to include opens, clicks, bounces, complaints, unsubscribes, sends, or delivery delays.
list_campaign_goals
ChatGPTList conversion goals for one email campaign. Returns campaign-specific goals in goals and Settings goals in companyGoals, including inactive goals. Company-wide goals apply automatically after an open or click within their window; manage them in Settings, not through campaign goal update/delete. SMS campaigns are not supported. Campaign goals are attributed to recipients who were sent that campaign (last-touch open/click still wins when the recipient engaged), and appear on the campaign report as named conversion steps after sent/opened/clicked.
list_campaign_variations
ChatGPTVariations are alternative versions of a campaign's email, compared side by side on the editor's Canvas tab. They never change what the campaign sends until use_campaign_variation. Labels: V1, V2, ... for versions of the email, V2.1, V2.2, ... for branches of V2. Lists the campaign's variations oldest first with status (generating, ready, failed), parentId (nearest variation it descends from that is not discarded), blocks, emailTheme and fontFamily (its own look, or null for the email's), position (where the user placed it on the canvas, or null), and inUse (the email currently has exactly this content). Discarded variations are not listed. Poll this after generate_campaign_variations until no variation is generating; one still generating after 10 minutes is reported as failed.
list_campaigns
ChatGPTList campaigns. Each item carries emailPreset, the linked email's Style > Format (branded or minimal; null for SMS campaigns and standalone raw HTML emails), so chrome can be compared across campaigns without one get_campaign call each. Each item also carries delivery pacing so an account-wide STO audit does not need one get_campaign call each: sendTimeOptimization, sendTimeWindowHours, spreadOverHours, sendInRecipientTimezone, and scheduledTimezone. STO is campaign-only; sequences use sendingWindow. Results are paginated: the default page size is 50 and limit is capped at 100. Always read the returned pagination object (limit, offset, count, total, hasMore) and keep paging with offset while hasMore is true - a single call does not necessarily return every campaign.
list_conversation_recipients
ChatGPTList the inbox addresses conversations started at, for list_conversations recipient filters.
list_conversations
ChatGPTList inbox conversations: replies to campaigns, sequences and transactional email, plus email sent to the inbox address (context.type inbox; recipientAddress says which address). Filter by status, search, unread, spam (only listed with spam true) or recipient, with pagination. Each conversation includes lastMessagePreview: a short plain-text preview of the latest subscriber or team reply (quoted history removed), or null.
list_data_export_runs
ChatGPTList recent export runs (last 14 days) with status, rows, files, bytes and errors.
list_data_exports
ChatGPTList data exports: destinations (S3, GCS or S3-compatible buckets) that Sequenzy streams email events, SMS events, custom events and daily subscriber snapshots to as gzipped JSON lines. Shows status, how far each dataset has been exported, and the last error. Credentials are never returned.
list_email_components
ChatGPTList the company's reusable email components newest first. Components are saved block groups that can be dropped into emails, plus the components pinned as company defaults for a slot (currently footer). Pass defaultsOnly to see only the pinned defaults.
list_email_metrics
ChatGPTList per-email metrics across the account: one row per campaign and per sequence email step, each with its own delivery funnel, attributed conversions, and revenueCents. This is the tool for cross-sequence questions - 'how many Email 4s went out across these sequences' is one call with step=4 plus the returned totals, instead of one get_sequence_stats per sequence. Sequence rows carry sequenceId, sequenceName, automationNodeId, and step, so you can group or compare steps yourself. Counts come from the retained event stream (not the 14-day list_email_sends history) and match get_sequence_stats steps[] for the same step. Filter by emailType, sequenceId, campaignId, and step; sort with sort/order; page with page/limit. totals covers every matching email, not just the current page.
list_email_references
ChatGPTList real emails from the Sequenzy email gallery to model a new email on, for the kind of email being written: campaign (promotions, newsletters, product updates), sequence (lifecycle emails plus whole sequences) or transactional. By default (scope similar) they come from the gallery brands most like the company: brands whose businesses (what each sells, and to whom) are closest in meaning to the company description, closest first (returned as brands; rankings are reused for up to 10 minutes). To rank them, the company description and any search text are sent to an embeddings service; nothing is saved. Each item has a gallery url that create_template_from_example (or create_sequence_from_example for a sequence) accepts, and emails carry an analysis (main button, length, layout, voice, structure and why it works; null until analyzed) to choose a model by. With scope all it browses the whole gallery instead; search narrows either. profile is missing (and the list empty) when the company has no description or company context yet; use scope all then. Requires templates:read.
list_email_sends
ChatGPTList and filter the recent sent-email delivery history shown in the dashboard. Search subject/title or recipient, filter by delivery status, email type, bounce type, or source ID, then pass a returned emailSendId to get_email_send for exact open/click timestamps and the complete event timeline. Each row carries recipientEmail, subscriberId, automationNodeId, abTestVariantId, and sent/delivered/opened/clicked timestamps, so rows join into a recipient-level delivery matrix without re-reading the raw event stream. Pass automationNodeId to list only the recipients of one sequence step. Delivery rows are retained for 14 days, so this is the wrong tool for send totals: read get_sequence_stats steps[] or list_email_metrics, which cover the full retained event window. Successful live-test and other test sends are omitted so they do not bury real deliveries; only failed, bounced, or suppressed test sends appear. Replies to those test sends show in list_conversations only when inbound reply capture is enabled; otherwise the send uses the original Reply-To and Sequenzy never sees the reply.
list_forms
ChatGPTList saved signup forms for a company, including their server-managed audience settings and public action URLs.
list_gallery_brand_requests
ChatGPTList this company's requests to add brands (usually competitors) to the Sequenzy email gallery, newest first. Each has a status: requested (not added yet), collecting (the brand is added and its emails are being collected), available (its emails are in the gallery; brand.url links to them and list_email_references can return them) or declined (with declineReason). Requires templates:read.
list_in_app_messages
ChatGPTList a contact's in-app messages and content cards (created by type "in_app" sequence steps). status "open" (default) is what their app should show now; "all" is history. Identify the contact by email, externalId or subscriberId.
list_integration_activity
ChatGPTRead recent integration webhook and sync activity, newest first. This is the log to check when an integration reports connected but contacts or events are not appearing: each row carries the action, status, event type, matched contact, and error. Payloads are sanitized at write time, so no credentials or secrets appear here. Activity is retained for 24 hours only.
list_integration_capabilities
ChatGPTDescribe what each integration Sequenzy supports, such as Stripe, Shopify or Clerk, provides, whether or not it is connected: category, how it connects, what it syncs, the events it emits and the moment each one fires, the subscriber attributes it writes, supported actions, availability, and caveats. Useful for questions like 'what would connecting Stripe give me?' or whether a provider emits the event a sequence needs. Read-only.
list_integrations
ChatGPTList connected integrations (Stripe, Shopify, Supabase, Clerk, WooCommerce, ad platforms, and so on) with connection status, sync state, last sync time, and last sync error. Read-only: credentials, access tokens, and webhook secrets are never returned. Use this to audit which external systems feed this account and whether their syncs are healthy.
list_landing_pages
ChatGPTList all landing pages for a company.
list_lists
ChatGPTList all subscriber lists. Each list includes subscriberCount (current members of any status) and activeSubscriberCount (current members with status=active). Members who unsubscribed from the list are not counted. Use these fields for list audience size instead of paging search_subscribers.
list_poll_responses
ChatGPTList individual Poll and NPS responses for a campaign, newest answer first, with each respondent's email, their answer and stored value, the subscriber attribute the answer was saved to, and the response time. get_campaign_stats reports the totals; this reports who answered what and when. Only each subscriber's latest answer per poll block is returned, so the counts match the campaign stats summary. Do not reconstruct respondents by scanning subscribers for the poll attribute - the attribute carries no response time and reflects the latest answer to any email. Multi-select answers list every selected option in answers/values. Results are paginated: read the returned pagination object and keep paging with page while page < totalPages.
list_products
ChatGPTList synced products (Stripe, Shopify, WooCommerce) including any attached digital delivery file. Useful before attaching a file or building a purchase sequence for a specific product. For Stripe products, variants are the product's active prices (variantId = Stripe price ID), so an exact price can be targeted even when it is not the default. Returns one page: check pagination.total and pagination.hasMore, and page with offset to read the whole catalog.
list_push_campaigns
ChatGPTList push campaigns, newest first.
list_push_devices
ChatGPTList registered push devices (browsers and app installs) in a stable order; pass nextCursor to page. Filter by contact (email or subscriberId), platform or status. Tokens are never returned in full.
list_receiving_domains
ChatGPTList receiving domains: domains and subdomains whose mail reaches the inbox (every address on them). A workspace has one; once verified, replies to emails from all its sending domains come back to reply addresses on it, like the tracking domain. Workspaces that set up several before keep them; replies then prefer the sender's own domain or one on the same root, else the oldest verified one. status verified: mail arrives and new reply addresses use it. pending: publish its records (a new name is reserved 7 days); until then replies use Sequenzy's shared address. failed: something broke; mail that still arrives is accepted, but new reply addresses use Sequenzy's address until fixed.
list_recipient_suppressions
ChatGPTList the recipients this company cannot reach: protected global invalid-recipient suppressions for addresses associated with the company, protected workspace hard bounces without conclusive invalid-inbox evidence, removable workspace soft-bounce escalations, and protected spam complaints. Each row includes a stable suppressionType, and the response echoes the applied sortBy/sortOrder. Sort by status to surface the suppressions you can actually remove. Start here when a customer reports missing email; use get_recipient_suppression for one exact address.
list_segments
ChatGPTList all segments.
list_sender_profiles
ChatGPTList sender (From) profiles and reply-to profiles for the company, including which are the account defaults and whether each sender address has verified DNS plus a ready home transport. Use this to audit sending identity before scheduling, or to pick a valid senderProfileId/replyProfileId for create_campaign or update_campaign.
list_sending_domains
ChatGPTList configured sending domains with separate DNS verification, sending readiness, and SPF, DKIM, and MAIL FROM status.
list_sequence_audience_enrollments
ChatGPTList recent audience enrollment runs for a sequence (newest first) with status queued/running/completed/cancelled/failed and counters estimatedCount, processedCount, enrolledCount, skippedCount. Use get_sequence_audience_enrollment to poll one run.
list_sequence_email_variations
ChatGPTDesign variations of one email of a sequence: alternative versions to compare before choosing one, like the Emails view of the sequence editor. They never change the email until use_sequence_email_variation. Lists the email's variations oldest first with status (generating, ready, failed), label (V1, V2, ...), name, summary, blocks, emailTheme and fontFamily (its own look, or null for the email's), and inUse (the email has exactly this content). In MCP Apps clients it shows them side by side, rendered, with buttons to use one. Poll it after generate_sequence_email_variations until none is generating; one still generating after 10 minutes is reported as failed. render_email with sequenceId, nodeId and variationId renders one.
list_sequence_enrollments
ChatGPTList the individual contacts currently enrolled in a sequence, with the node each one is sitting on. Use this when get_sequence_stats gives you enrollmentCounts and you need the actual subscribers behind a number, such as everyone waiting at one step. Filter by currentNodeId (take the ID from get_sequence_stats enrollmentCounts.byCurrentNode or get_sequence nodes), status, subscriberId, or email, and page with limit/offset to export the full list. The response always echoes the sequence's single configured stopCondition, including matchConfig filters or comparisons. A stop condition does not cancel a waiting enrollment when its event arrives: it is re-evaluated when the enrollment next runs a step, so an enrollment parked on a delay keeps reporting waiting until that delay expires. Pass stopConditionMatch true to see whether each in-flight enrollment's stop condition matches right now. This is a non-atomic snapshot: a step already past its stop check may still finish. Each enrollment also reports enteredVia - the list, tag, segment, event, inactivity check, or frequency check that enrolled it - which is how you tell apart contacts entering a sequence whose trigger covers several lists or tags. entryContext adds the event id, property keys (never values), and trigger type. branchDecisions records the bounded retained if/else (or random split) verdicts, including the compared field name and a redacted value summary (missing/empty/nonempty/equals_expected); branchDecisionCount and branchDecisionsTruncated tell you when older verdicts were omitted. For the ClickHouse graph walk of one completed token, use get_sequence_enrollment. Live sequence tests do not create enrollments; they send isolated test emails and record activity on the sequence test run instead.
list_sequence_events
ChatGPTList paginated raw email events for every email step in a sequence, or for one step via automationNodeId. Defaults to deliveries; use eventType or eventTypes to include opens, clicks, bounces, complaints, unsubscribes, sends, or delivery delays. This is the per-recipient event stream - do not page it to count sends. Per-step and per-sequence totals already exist as get_sequence_stats steps[], and list_email_metrics gives the same per-step totals across many sequences at once.
list_sequence_goals
ChatGPTList persisted conversion goals attached to one sequence in the dashboard.
list_sequences
ChatGPTList all email sequences (automations). Read effectiveStatus (draft, live, enrollment_paused, paused, archived) to know whether a sequence is running: status alone reads active even when new enrollments are paused, and the legacy triggerConfig.active flag is not used by the runtime.
list_subscriber_attributes
ChatGPTList the custom attribute names in use across the account, each with its value type (string, number, or boolean), whether it holds a list (isArray), an example value, and how many of the sampled recent contacts carry it. Call this before add_subscriber or update_subscriber to reuse existing names and match their types, e.g. send a zip code as the string "02134" rather than a number. Names only older contacts carry are included with sampledContacts 0. mixedTypes is true when contacts hold different types for a key; valueType is then string. Always send values with leading zeros as strings, whatever valueType says.
list_subscriber_notes
ChatGPTList internal notes for a subscriber. Provide email or externalId to identify the subscriber.
list_subscriber_operations
ChatGPTList the company's 20 most recent background tagging operations, including progress and failures.
list_tags
ChatGPTList all tags in the account.
list_team_members
ChatGPTList team members for the company, including the owner, members with their roles, and pending or expired invitations.
list_templates
ChatGPTList the company's email bodies newest first, including per-locale localization sync status and each body's emailPreset Style > Format (branded or minimal; null for standalone raw HTML). Results include standalone templates plus the bodies behind campaigns and transactional emails. Returns 50 per call by default (100 max); page with offset while pagination.hasMore is true, and read pagination.total for the full count. You can also pass a campaign's emailId to get_template to fetch one body directly. Bodies are kept when their campaign or transactional email is deleted.
list_transactional_emails
ChatGPTList transactional email templates with subjects, delivery metrics, API slugs, and dashboard URLs. Each item also carries emailPreset, the per-email Style > Format (branded or minimal, null for a standalone raw HTML email), so a chrome drift check across templates does not need one get_transactional_email call each. managedBy is code for emails created by send_email with trackAs: their content is a snapshot of recent sends and they cannot be sent by templateId. Search by name, slug, or email title; filter active state; and sort by sends, opens, open rate, clicks, or CTR.
list_warehouse_connections
ChatGPTList warehouse connections (Snowflake, BigQuery, Redshift, Postgres) with status, last test and number of syncs. Credentials are never returned.
list_warehouse_sync_runs
ChatGPTList recent sync runs (last 30 days) with rows read, synced, unchanged, skipped and failed, sample row problems, and import progress.
list_warehouse_syncs
ChatGPTList warehouse syncs with schedule, status, cursor position and the latest run, including progress of the subscriber imports it queued.
list_watched_brand_emails
ChatGPTRead the marketing emails that watched brands sent to their public mailing lists, as collected in Sequenzy's public email gallery, newest first, a page at a time: subject, type, subtype, sentAt, collectedAt, brand, url and a breakdown (analysis, null until analyzed). Pass domain for one brand and since for emails sent at or after a time (for example the start of this week). Emails arrive a few hours after they are sent, so when polling set since about a day before the last check and skip ids already seen. Pass nextCursor back as cursor for older emails. Each url also works as the url of create_template_from_example to remix it. Read-only. Requires templates:read.
list_watched_brands
ChatGPTList the brands (usually competitors) this company watches, newest watch first. Each has a status: available (its emails are in the gallery; emailCount and latestEmailAt say how many and how recent), requested (not in the gallery yet), collecting (added, emails on the way) or declined (with declineReason). Use list_watched_brand_emails to read what they sent. Requires templates:read.
list_web_tracking_keys
ChatGPTList the publishable keys that let a non-Shopify website send on-site events (product views, cart activity, collection views, search, and page views reported with sequenzy.page()) into this workspace. Whether browse abandonment, cart recovery, or any product-view trigger can work on a custom site depends on an installed key: without one those events never arrive, the sequences built on them never fire, and nothing reports an error anywhere. Each key returns allowedOrigins, unrestricted, lastUsedAt, and a paste-ready installSnippet. A key with lastUsedAt: null has not successfully authenticated an event yet; it may be undeployed, have no instrumented traffic, or be sending requests rejected by its origin allowlist. Shopify stores do not use these keys; they use the storefront pixel, which get_integration_pixel reports.
list_webhooks
ChatGPTList outbound webhook endpoints and their subscribed event types.
mark_conversation_read
ChatGPTMark all unread inbound messages in a conversation as read. Records the caller as reader on each message; mark_conversation_unread re-flags only the latest received message.
mark_conversation_unread
ChatGPTMark a conversation unread again, for example to leave it for a teammate. Its latest received message becomes unread.
monitor_subscriber_import
ChatGPTShow a compact progress card for an existing subscriber import. Reads immediately, then polls get_subscriber_import every five seconds for up to five minutes while running. Refresh resumes monitoring. Requires explicit companyId and importId. Does not start or retry an import. Other clients receive the import data.
move_sequence_enrollments
ChatGPTRelease a bounded batch of contacts off one sequence step and onto another, keeping their existing enrollment. Use this to let the next N contacts waiting on a delay continue early instead of cancelling and re-enrolling them, which discards the enrollment's entry event properties and stop-condition snapshots. Provide sequenceId and fromNodeId; targetNodeId defaults to the source step's only next step. Defaults to dryRun, so pass dryRun false to actually move. Moved contacts become active on the target step immediately, so this sends email as soon as the worker picks them up. limit defaults to 100 and is capped at 500 per call: while remainingCount is above zero, call again to release more. Unlike enroll_subscribers_in_sequence this still works while the sequence has new enrollment paused, because the contacts are already enrolled.
move_sequence_step
ChatGPTReorder a sequence by moving one step so it runs right after or before another step. Branch steps themselves can't be moved. Edits are checked against graphRevision from get_sequence, so changes made in the meantime are never overwritten. For an active sequence, set confirmStructuralChange once the user approves the change. On an active sequence, contacts follow the new order from their next step, changing which emails they receive and when.
open_image_upload
ChatGPTOpen a compact image picker as a supporting workflow for email creation. Opening does not upload anything; the user chooses an image and explicitly submits it through upload_image_asset. Requires an explicit companyId. Clients without MCP Apps can use upload_image_asset directly.
pause_campaign
ChatGPTPause a campaign that is currently sending. Only campaigns in sending status can be paused. Use resume_campaign to continue delivery later.
pause_sequence_enrollments
ChatGPTStop new enrollments for an active sequence while current recipients continue through the sequence. This matches the dashboard 'Stop new enrollments' control and does not freeze current recipients. Trigger events that arrive while enrollment is paused do not enroll those contacts later.
preview_accounts_from_organization_id
ChatGPTPreview the biggest accounts create_accounts_from_organization_id would make, before anything is written. Each organization has externalId (its ID), name (from nameKey, otherwise from the work email domain most of its contacts share, null when neither exists), domain, contactCount and up to 3 sampleEmails. Read-only; always show this preview to the user and get confirmation before creating accounts.
preview_cart_items
ChatGPTPreview cart/order data without saving or sending. Returns explicit field-mapping suggestions, ambiguous numeric price candidates, visual preset settings, and previewItems for the selected scenario. Existing itemFields are preserved. Apply chosen suggestions/preset fields using update_sequence_node or template/campaign updates; render_email accepts the previewItems at your block source in variables. Scenario data is sample-only; use real to restore the supplied items. Price candidates have unknown units: confirm cents before mapping priceCents; set priceUnit to major for major-unit prices; omitted priceUnit preserves cents. No account data is read. Works with any connected Sequenzy account; no additional permissions.
preview_default_email_component
ChatGPTPreview a proposed default footer without saving or sending. Provide the proposed blocks and explicit application scopes. Returns affected counts, every affected/skipped email and a token for set_default_email_component. The application scopes select which categories to update: sequences, draft/scheduled campaigns, transactional templates, reusable templates, or future emails only. Customized footers are preserved unless explicitly included. Set renderPreview to get footerHtml and before/after HTML samples, one per selected category; open or save that HTML and use a browser to inspect the visual result. Use sample with an affected id/kind to render a particular email version. Previews are layout-only, without recipient personalization. A stale apply returns conflict; preview again instead of silently retrying with a new token.
preview_sequence
ChatGPTShow an interactive visual preview of a saved sequence in clients that support MCP Apps. Displays its real nodes, connections, delays and branches; click an email step to preview its saved rendered email, including available A/B variants, at desktop or mobile width. Read-only: does not activate, enroll or send. Requires an explicit companyId to keep step previews pinned to the same company. Other clients receive the sequence data; use render_email for individual step HTML.
preview_sequence_from_example
ChatGPTPreview the first 3 emails of a public Sequenzy email gallery sequence written for this company, without creating a sequence or email (a company's first AI generation saves its inferred email design direction, like generate_email). Each email keeps the example's layout with every word rewritten; returns subject, previewText, HTML and the original day for each, plus how many emails were left out. Pass website to write it for another site's brand instead. Requires sequences:write. Takes 10-30 seconds. Call create_sequence_from_example to create the draft sequence with every email. Accepts a gallery sequence URL or brand plus sequence slugs. With website, the site is looked up with a brand data provider and its pages are fetched; without it, a blank company email design prompt is filled in.
preview_template_from_example
ChatGPTPreview how a public Sequenzy email gallery email would read for this company without saving any email (a company's first AI generation saves its inferred email design direction, like generate_email): the same rewrite as create_template_from_example (the example's layout, every word written for the company, its logo, brand color and links swapped in), returned as subject, previewText and HTML. Pass website to write it for another site's brand instead, such as a prospect or client; it is looked up like the gallery's public preview. Requires templates:write. Takes 5-20 seconds. Call create_template_from_example to keep it as a template. Accepts a gallery email URL or brand plus email slugs. With website, the site is looked up with a brand data provider and its pages are fetched; without it, a blank company email design prompt is filled in.
publish_landing_page
ChatGPTPublish a landing page. Optional name, slug, or content updates are saved before publishing.
realign_sequence_enrollments
ChatGPTPull waiting enrollments forward to the start of the sequence's sending window on the day they are already scheduled for. Use this after changing sendingWindow (or a wait-until-weekday step) on a live sequence: node and sequence updates deliberately keep existing wait timestamps, so contacts already parked on an email-bound delay keep resuming at whatever minute their delay landed on, and a narrowed window silently defers them to the NEXT allowed day. Non-email actions are never advanced by the sequence sending window. Realignment never cancels, re-enrolls, or reschedules onto a different local day, and never pushes a contact later - a wait only ever moves earlier within the day it already has, and never earlier than now. Defaults to dryRun. Passing dryRun false queues a background apply and returns jobId; call get_sequence_enrollment_realignment until it completes. Each completed job is capped: when result.hasMore is true, queue another apply with result.nextCursor as cursor. Applied realignment makes affected contacts receive their next email earlier and is not reverted.
record_in_app_event
ChatGPTRecord that the app displayed, clicked, dismissed or read an in-app item. Repeats change nothing except clickCount. Clicks, dismissals and reads also count as a display. Messages leave the open feed once displayed, clicked or dismissed; cards once dismissed. Segment membership is re-evaluated, so running segment-entered or -exited sequences can email affected contacts.
release_sms_number
ChatGPTRelease an SMS number: hand it back to the carrier and mark it released. This is IRREVERSIBLE - the number cannot be recovered afterward, any campaign/sequence still explicitly set to send from it will SKIP its SMS sends until repointed at another number, and it stops counting toward the workspace's number limit (freeing a slot for a new purchase). Use get_sms_settings to find the number ID. Requires workspace-management permission.
remove_account_member
ChatGPTRemove a contact from an account. The contact is kept; its account.* attributes are cleared or replaced by another account it belongs to. Segment membership is re-evaluated, so running segment-entered or -exited sequences can email affected contacts.
remove_apns_credentials
ChatGPTRemove APNs credentials. iOS devices stop receiving push until a key is saved again in the dashboard; registered devices are kept.
remove_fcm_credentials
ChatGPTRemove Firebase credentials. Android devices stop receiving push until a key is uploaded again in the dashboard; registered devices are kept.
remove_gallery_brand_request
ChatGPTWithdraw one of this company's brand requests by id (from list_gallery_brand_requests). The brand stays in the gallery if it was already added. Requires templates:write. Deleting the request also stops watching that brand, since a watch and its request are the same record.
remove_landing_page_domain
ChatGPTRemove the dedicated custom domain from one landing page. The page keeps its workspace and Sequenzy fallback URLs. Releases the hostname from the hosting provider (Vercel), so the page stops loading at that custom domain and existing links to it break.
remove_product_file
ChatGPTRemove the attached distributable file from a product. Later purchase emails that use {{event.download.url}} no longer get a download link for this product.
remove_push_device
ChatGPTUnsubscribe a push device and unlink it from its contact so it stops receiving push. A browser or app that still allows notifications can register again (browsers come back unlinked). Segment membership is re-evaluated, so running segment-entered or -exited sequences can email affected contacts.
remove_receiving_domain
ChatGPTDestructive: remove a receiving domain. All mail to it stops, including replies to emails already sent with reply addresses on it, and a branded inbox address on it is cleared. Confirm with the user first. Owner or admin only.
remove_recipient_suppression
ChatGPTRemove a workspace-scoped soft-bounce escalation for an exact recipient associated with the company, then reactivate bounced company subscribers. Global invalid-recipient, workspace hard-bounce, complaint, and unsubscribe suppressions are protected. Reactivated contacts become eligible for live campaigns and sequences again, so mail to the address resumes.
remove_subscriber
ChatGPTUnsubscribe a subscriber while preserving the record and suppression history. Only permanently deletes when hardDelete is true. Unsubscribing also cancels the contact's active sequence enrollments; hardDelete also removes notes, list memberships and push devices.
remove_subscribers_from_list
ChatGPTRemove subscribers from a list by email address. Maximum 500 emails per call. Subscribers stay in the account; only the list membership is removed. Returns the removed count plus a notFound array of emails that did not match a subscriber. Segment membership is re-evaluated, so running segment-entered or -exited sequences can email affected contacts.
remove_tracking_domain
ChatGPTRemove the company tracking domain. New emails use the shared Sequenzy tracking domain, and links in emails already sent through the removed domain stop working. Confirm with the user first.
render_email
ChatGPTRender an email with a sample contact or caller-supplied, policy-checked subscriber and variables. Rendering against a stored subscriber ID is unavailable here because stored custom attributes cannot be inspected before personalization.
render_landing_page
ChatGPTRender a visitor-facing preview of a landing page without publishing it. Unlike get_landing_page, which returns builder JSON, this returns previewUrl: a signed, unlisted URL that shows the page with the same layout, theme, form, and #form button anchors visitors will see. Drafts keep publicUrl and appPublicUrl null until publish_landing_page; open previewUrl to check copy and layout on a draft instead of putting unreviewed content on the public domain. The preview is not indexed. Signup forms on a draft preview do not collect contacts. This is read-only and never publishes, unpublishes, or changes the page.
replace_sequence_paths
ChatGPTRewire which steps follow which in a sequence, including branch paths, by passing the complete updated list of connections. Edits are checked against graphRevision from get_sequence, so changes made in the meantime are never overwritten. For an active sequence, set confirmStructuralChange once the user approves the change. On an active sequence, contacts follow the new connections from their next step, changing which emails and actions they receive.
reply_to_conversation
ChatGPTSend a reply in a conversation, or add an internal note. type 'outbound' (default) emails the subscriber and requires bodyText or bodyHtml; type 'note' adds a private team-only note. When the conversation has a recipientAddress (the inbox address it was sent to), list the sender profiles first and, if one's email equals that address, reply from it with senderProfileId. Replying to a closed conversation reopens it. Each successful outbound call sends another email, so after a timeout check the conversation with get_conversation before retrying.
request_gallery_brand
ChatGPTSuggest a brand, such as a competitor, for Sequenzy's public email gallery, so its marketing emails can be used as design references. Pass its website or domain. This call only records the suggestion: Sequenzy reviews it and, if the brand is added, signs up to the brand's public mailing list like any reader. Suggesting the same domain again keeps the one request (a new note replaces the old) and returns created false. If the brand is already in the gallery, the request comes back with status available. A company can keep up to 50 requests and cannot suggest its own website. Requires templates:write.
restart_ab_test
ChatGPTRun another sequence A/B test after a winner is selected. By default the winner becomes the new control; pass sourceVariantId to use another variant as the control email. On an active sequence the step switches to the new test once its variants are ready, so contacts reaching it receive the new variants.
restore_campaign_variation
ChatGPTBring back a discarded campaign variation with its label; its branches move back under it.
resume_ab_test
ChatGPTResume a sequence A/B test (nodeType action_ab_test) that already has a winner, for example one picked automatically before the user was sure. Clears the winner so contacts reaching the step are split across the variants again, keeps the results collected so far, and turns off automatic selection for this test: it keeps splitting until a winner is selected with select_ab_test_winner. Pass confirmLiveChange when the sequence is active.
resume_campaign
ChatGPTResume a paused campaign. Only campaigns in paused status can be resumed. Optionally spread the remaining delivery over a number of hours.
resume_sending
ChatGPTRequest that paused company-level sending be restored after fixing the cause. This is the supported remediation path for an account paused by the permanent-bounce rate limit - it is not a bypass and it never removes suppressions. Intended for after the bad source (import, form, or integration) is actually fixed while permanent bounces remain suppressed. get_sending_status reports the current gate: for a paused workspace, resume only restores sending when selfResume.canSelfResume is true, which requires a hard-bounce pause reason, a cleared automated sender-health review, and no admin block. A workspace that is already active succeeds as a no-op with resumed: false; any other blocked state needs a support review, and the error names which one. listSanitizationConfirmed: true is required and represents the user's confirmation that the remediation is done; it is recorded on the account's audit trail as their statement that the list is clean. On success, sending is restored, the bounce watermark resets so the rate is recalculated from later sends, and the service attempts to requeue paused campaigns plus due sequence steps. The response message contains support guidance if part of that queue handoff is temporarily unavailable. Requires the companies:manage scope and owner or admin access to the company.
resume_sequence_enrollments
ChatGPTResume new enrollments for an active sequence whose enrollment gate was paused. Use enable_sequence instead for a fully disabled/frozen sequence. New trigger matches start receiving the sequence's emails again.
run_account_health_check
ChatGPTQueue an account health check now and return the run. If a check is already queued or running it is returned with alreadyInProgress true instead. Manual checks are limited to one every 10 minutes and wait a day after a check that left findings open (both 429 RATE_LIMITED with retryAfterSeconds), need more than 1,000 active subscribers and an email sent in the last 14 days (409 NOT_ELIGIBLE), and never send the report email. The check usually finishes within a minute; poll get_account_health until runInProgress is false. Requires sequences:write. The check's AI agent can read pages on the company's website; the run resolves, reopens or rewrites existing findings and, with draft_fixes autonomy, creates inactive draft sequences.
run_data_export
ChatGPTStart an export now instead of waiting for the schedule. Poll list_data_export_runs or get_data_export for progress. Paused exports must be resumed first. Queues a job that writes email, SMS, event and subscriber data files to the destination bucket.
run_warehouse_sync
ChatGPTRun a sync now. With fullResync, the run forgets which rows were sent and sends every row again (use after changing data outside the cursor). Poll list_warehouse_sync_runs for progress. Runs overwrite contacts' mapped fields; with fullResync on a triggering sync, every row can start automations again.
save_email_ai_style
ChatGPTSave an email's appearance as the company default for future AI generation. Captures fonts, colors, spacing and block treatments, plus detected layout habits (for example dotted dividers around every button) and optional notes, without copying its content or modifying existing emails. Requires emails:write and access to the source email. Replaces only expectedStyleId; get and review the current style before replacing. All detected habits are kept unless layoutRuleIds narrows them; review style.layout.rules in the response and re-save with a subset if needed. Plain-text choices and explicit style requests take precedence during generation.
schedule_campaign
ChatGPTSchedule a draft or already scheduled campaign as a one-off send or on a repeating weekly/monthly cadence via recurringInterval. The campaign must have a non-empty subject, at least one content block, and at least one audience include rule or an explicit selected contact. Use recurringInterval for newsletters that go out on a fixed schedule instead of creating one campaign per issue. Send Time Optimization (sendTimeOptimization) delivers each recipient at their predicted best hour within sendTimeWindowHours of scheduledAt (default 12h, max 24); it is campaign-only and is not available on sequences. spreadOverHours takes precedence and turns STO off; sendInRecipientTimezone also turns it off. Returns dashboard edit and preview URLs; validation errors explain what must be fixed before retrying. Only draft or scheduled campaigns can be scheduled, so a repeat call replaces the schedule and cannot send the campaign twice.
search_subscribers
ChatGPTSearch the company's own contacts by free-text query, tags, list, segment, custom attribute, or opt-out date, for example to check one contact's status or to size an audience. Each contact carries unsubscribedAt, the date the contact opted out; use it rather than updatedAt, which any later tag or attribute write overwrites. Omitting limit returns every match in one call. To page through a large audience instead, pass limit and follow pagination.nextCursor (or pagination.nextOffset) until pagination.hasMore is false. Default searches are newest first; searches with attribute use stable subscriber-ID ascending order. Read-only.
select_ab_test_winner
ChatGPTSelect a winner for an A/B test. For a campaign A/B test that is currently testing, this queues the winning variant for the remaining audience and starts external email delivery. For a sequence A/B test (nodeType action_ab_test), this selects or changes the winner, including one picked automatically: everyone who reaches the step afterwards gets the new winner, and contacts who already got a variant keep it. Pass confirmLiveChange when the sequence is active.
select_company
ChatGPTSelect which company to operate on (for connections with access to multiple companies). Use get_account to see available companies. After selecting, all subsequent operations will use this company unless you pass a companyId override. The selection is stored for this connection and replaces the previous one for every later call without companyId, including calls from other chats on the same connection.
send_email
ChatGPTQueue one email using either a saved transactional email API slug (templateId) or direct subject and html content. Add trackAs to a direct send to track it under one code-managed transactional email for per-email stats. Always provide a stable idempotencyKey when an agent or workflow may retry, and reuse it for the same logical email; Sequenzy returns the original send for 14 days and rejects different content under the same key. The default delivery policy is transactional. A transactional send delivers one email to several people at once: to takes up to 50 addresses and cc/bcc take up to 50 each, so everyone sees the same shared recipient list instead of receiving separate copies. Addresses repeated across the fields are dropped from the lower-priority one (to beats cc beats bcc). When the recipient matches a subscriber, saved first and last names fill omitted name variables; explicit variables take precedence. Set emailType to marketing to add subscriber suppression, a marketing footer, and RFC 8058 one-click unsubscribe; marketing sends take exactly one to recipient and no cc or bcc. When no identity override is provided, a template send keeps its saved From and Reply-To identities, while a direct send uses the company defaults. To send as a non-default verified brand, pass fromEmail (and fromName if that address has several identities) plus optional replyTo/replyToName; you do not need profile IDs. senderProfileId/replyProfileId from list_sender_profiles remain available when you already have them. These fields look up existing identities and do not create profiles. {{viewInBrowserUrl}} is replaced with a hosted copy URL. Attach up to 10 files with Base64 content or a public path; contentId embeds a CID image referenced by the HTML. When trackingSettings is omitted, the company's Transactional API defaults apply. Set clickTracking or openTracking to false to opt out for this send only; these fields cannot enable tracking disabled by account settings. Use headers for extra email headers, such as your own one-click List-Unsubscribe on a transactional send. Returns a durable emailSendId, the accepted emailType, the deduplicated recipient lists, and ignoredHeaders when some headers were not applied; pass the ID to get_email_send for delivery status and failure details.
send_push_campaign
ChatGPTSend a push campaign now, or schedule it with scheduledAt (future ISO 8601). Delivers real notifications to every contact in the audience with an active device on a set-up platform. Confirm with the user before calling.
send_sequence_test_email
ChatGPTQueue a real test send for one saved action_email step in a sequence. Call get_sequence first and pass the target sequence.emails entry's nodeId only when nodeType is action_email; action_ab_test steps are not supported by this tool - inspect variant copy on get_sequence.sequence.emails[].abTest.variants. Accepts 1-10 reviewer email addresses and returns one durable emailSendId per recipient for get_email_send delivery inspection. The sequence is not enabled and no subscribers are enrolled. Each successful call sends another set of test emails.
send_test_email
ChatGPTQueue a campaign test email to a single address. Returns a durable emailSendId; pass it to get_email_send for delivery status and failure details. Each successful call queues another test email.
send_test_push
ChatGPTSend a real test push to one device (deviceId) or to every active device of a contact (email or subscriberId). Provide title and/or body. Limited to 200 per company per rolling 24 hours; excluded from stats.
send_test_sms
ChatGPTSend a test SMS to a phone number. This delivers a real text message and consumes SMS credits from the workspace's existing balance based on destination, message segments, and media; it never purchases credits or changes the plan. Intended for user-requested test sends. Requires the SMS add-on with a verified number (see get_sms_settings). Limited to 100 test sends per company per rolling 24 hours; bypasses quiet hours; excluded from step stats. Each successful call sends another text, so after a timeout check with the user before retrying.
set_default_email_component
ChatGPTCreate or replace the company's default component for a slot. This is the supported way to change the footer on every email: sequence, campaign, and AI-generated emails built from blocks clone this component when they are built, instead of the generated default footer. Raw HTML emails are the exception - block chrome cannot be injected into raw HTML, so they keep their own markup and a generated unsubscribe footer is appended at send time unless the HTML contains {{unsubscribeUrl}}. Call get_default_email_component first and edit the blocks it returns, otherwise you replace the existing footer wholesale. A default footer always keeps its unsubscribe link enabled - transactional sends hide it at render time. Omitting application keeps existing emails unchanged. To apply to existing emails, call preview_default_email_component first, then pass the same application, blocks and metadata with its token as previewToken. This atomically saves the default and updates only the previewed eligible content. It does not send emails. Customized footers are preserved by default. Conflict means the preview is stale and must be reviewed again.
set_frequency_cap
ChatGPTSet or change the company frequency cap: at most maxEmails marketing emails per contact in any windowHours. Applies from the next email step onward to sequences with frequencyCapEnabled (set it with create_sequence or update_sequence). Campaigns count toward the cap but always send. Transactional emails never count and are never skipped. A sequence email step skipped under the cap is not sent later; the contact moves on to the next step.
set_integration_list_targeting
ChatGPTChoose which lists the contacts a connected integration creates join. This is the tool for 'stop this integration adding people to my marketing lists' - set_integration_sync_enabled only pauses bulk backfills and leaves the provider's live webhook writing. Scope: this changes list membership only, and it takes effect on future provider writes. It does not stop contacts being created, does not stop their attributes syncing, does not stop sync-rule tags, and does not stop contact_added sequences using the default any_contact scope, which fire precisely because the contact joined no list. Explicit any_list and specific-list sequences require a matching membership and do not enroll a list-less contact. Nobody is ever removed from a list and nothing is applied retroactively. Provider behavior for existing contacts differs: Wix or Webflow submissions, Shopify customer updates, and Supabase resubscriptions can add an existing contact to the new target lists; Stripe applies targeting only when its webhook creates a subscriber. Webflow is deliberately fail-closed: null is rejected, so pass [] or explicit list IDs; form selection, field allowlists, required double opt-in, and sequence enrollment remain dashboard-only under Settings -> Integrations -> Webflow. With no selected forms, Webflow capture is off and no contacts are created. If the goal is to stop any_contact enrollments too, pair this tool with pause_sequence_enrollments on the affected sequences. Check get_integration first - ingestion reports the current targeting with list names, and availableActions says whether this provider honors set_list_targeting. Supported for Supabase, Stripe, Shopify, Wix, and Webflow. Dodo Payments, PostHog, Polar, Paddle, and other providers without that action reject this tool; their live contacts follow defaultSubscriberListIds on get_company/update_company instead (null = every list, [] = none), which is workspace-wide. PostHog history imports are an exception and create contacts without list memberships. Idempotent: asking for the current state succeeds with changed: false. Requires the integrations:manage permission, which this connection does not include by default - without it, report the dashboard path (Settings -> Integrations) instead of retrying. Contacts synced later join the chosen lists and can start those lists' contact_added sequences.
set_integration_sync_enabled
ChatGPTTurn a supported integration's future bulk imports and backfills on or off. THIS DOES NOT STOP AN INTEGRATION CREATING CONTACTS: disabling sync only pauses full imports and backfills, while the provider's live webhook keeps writing every new signup or customer as it happens. To change where those contacts land, use set_integration_list_targeting; to stop them arriving at all, use disconnect_integration for Lemon Squeezy or disconnect from the dashboard for other providers. Check get_integration.availableActions first; providers without enable_sync or disable_sync are dashboard-managed. Disabling keeps the connection, credentials, and live webhook delivery active, and requires any in-flight sync to finish first. It does not disconnect the integration. Idempotent: setting the current state succeeds with changed: false. Requires the integrations:manage permission, which this connection does not include by default - without it, report the dashboard path (Settings -> Integrations) instead of retrying. Enabling resumes background imports from the provider, which add or update contacts.
set_template_localization
ChatGPTCreate or replace one caller-supplied localized variant of a template. The locale must be enabled for the company and cannot be its primary locale. Provide exactly one of html or blocks. By default, automatic translation on save replaces it when the original changes. Set keepEdits to protect it like a dashboard edit: it is marked as edited (editedAt) and becomes stale instead of being replaced. Contacts in this locale receive the variant on live sends of the email, so replacing it changes what they get next.
set_tracking_domain
ChatGPTSet or change the company tracking domain: one hostname every sending domain uses for tracked links and opens, for example links.example.com. Any subdomain the user controls works; a bare root domain is rejected. Publish the returned trackingDomain.cnameRecord. It never blocks sending: until it verifies, links use the shared Sequenzy domain. Changing it keeps the previous hostname serving links in emails already sent while its old CNAME stays. Confirm the hostname with the user first. Registers the hostname as a custom hostname with Cloudflare, the tracking provider, which issues its HTTPS certificate.
share_campaign
ChatGPTCreate (or fetch) the campaign's public view-in-browser link. The hosted page renders an anonymized copy - sample contact, inert unsubscribe link, no open/click tracking - so the URL is safe to forward to anyone, unlike a recipient's personal browser copy. Idempotent: if a link is already active, the same URL is returned with created=false rather than rotating it, so previously shared copies keep working. get_campaign reports the current link as shareUrl (null when none). Revoke with unshare_campaign. Email campaigns only - SMS campaigns have no browser view.
share_template
ChatGPTCreate (or fetch) the public view-in-browser link for an individual email - a transactional email, a sequence email, or a standalone template. Accepts an email/template ID or a transactional email's ID or slug; for a sequence email, pass the step's emailId from get_sequence. The hosted page renders an anonymized copy - sample contact, inert unsubscribe link, no open/click tracking - so the URL is safe to forward to anyone. Idempotent: if a link is already active, the same URL is returned with created=false rather than rotating it, so previously shared copies keep working. get_template reports the current link as shareUrl (null when none). Revoke with unshare_template. Campaigns have their own campaign-level link that follows the A/B winning variant - use share_campaign for those.
simulate_sequence
ChatGPTDry-run a sequence without sending mail or enrolling anyone. Requires sequences:read and subscribers:read because results include contact samples. Activation does not enroll existing matches unless audienceAutoEnroll is saved. Without a subscriber this reports who currently matches (existing list/tag/segment matches are not auto-enrolled) and activation readiness errors. Frequency and inactivity current-match counts are unavailable because the hourly worker evaluates them. Pass subscriberId or email to also walk that stored contact's branch path - use this to check whether a specific contact would receive a given step. Call this before enable_sequence.
start_sequence_test_run
ChatGPTRun real sequence actions for one active subscriber, including webhooks, tags, attributes and discounts. Emails are marked as tests. Requires sequences:activate and subscribers:read. Does not enable the sequence. Optional customVariables supplies trigger event properties, including nested objects and arrays, available as event.*. Use get_sequence_test_run to inspect progress. A failed run can have completed side effects; inspect before starting again. Ordinary failure retries are disabled. Stalled-job recovery can replay actions after worker loss.
start_subscriber_operation
ChatGPTAdd tags to a whole filtered audience in the background. Returns a durable operation ID; poll get_subscriber_operation or list_subscriber_operations. Reuse requestKey after an uncertain response; changing inputs with the same key is rejected. Tagging needs subscribers:tag, new definitions need tags:write, and triggerAutomations needs automations:trigger. Existing synchronous bulk tag tools remain suitable for up to 500 explicit contacts. With triggerAutomations true, tag_added sequences start for every tagged contact and can email them; tags already applied stay if the operation is cancelled.
submit_account_health_feedback
ChatGPTTell the Sequenzy team whether an account health insight (id from get_account_health) was useful to the user: rating useful or not_useful, with an optional comment on why. Use it when the user says a finding or suggestion helped or missed, in their words; do not rate on their behalf. It records the connected user's own answer and changes nothing in the workspace (to hide a finding use update_account_health_insight). One answer per person per insight: submitting again replaces the rating and keeps the earlier comment unless comment is passed (null clears it). Works for insights of any status. 404 for an unknown insight. Requires analytics:read. The rating and comment are sent to the Sequenzy team's Telegram chat.
sync_audience_now
ChatGPTTrigger an immediate upload of the segment's subscribers to its Meta custom audience, outside the regular schedule.
sync_integration
ChatGPTQueue a manual re-sync for an integration: customers and revenue for a payment provider (Stripe, Polar, Paddle, Dodo, Lemon Squeezy, Creem, Chargebee, Whop), the user backfill for Supabase, or the event-history import for PostHog and Segment. Use this for Supabase before a campaign that depends on names or plan attributes - the live trigger only sends rows that change after it was installed, so existing users have no attributes until a backfill runs. The Supabase sync reads the project, schema, and table already configured for the integration and cannot be pointed at a different table; if none is configured yet it fails saying so. This is also the supported way to retry a failed PostHog or Segment history import: it restarts from the beginning using the stored credentials, and already-imported events dedupe, so a re-run cannot duplicate them. Returns immediately - poll get_integration to watch syncStatus and lastSyncAt, and list_integration_activity for per-row outcomes. Fails with a conflict if a sync is already queued or running; terminal BullMQ failures release history imports for retry. Providers whose backfill is not API-triggerable (Shopify products, Affonso affiliates) return a clear error naming the dashboard. Check availableActions on get_integration to see whether this is supported before calling. Synced provider data replaces subscribers' previously synced attribute and revenue values.
sync_products
ChatGPTQueue a sync of the Stripe product catalog into the products list. Requires an active Stripe integration with bulk sync enabled. Pass integrationId when more than one Stripe account is connected; otherwise the most recently connected enabled account is used. The sync overwrites stored Stripe product details and marks products no longer active in Stripe as out of stock.
sync_template_localizations
ChatGPTQueue AI translation for selected template locales. Omit locales to sync every enabled non-primary locale. This works even when automatic on-save localization is disabled. By default it also retranslates locales someone edited; set skipEdited to keep those and get them back in skippedLocales. Completed translations replace stored locale variants, which live sends to contacts in those locales use.
test_data_export
ChatGPTWrite a small test file to the data export's bucket to confirm the stored credentials still work. Returns a readable reason on failure. Each test writes the probe object to the same key under the export's path prefix, replacing the previous probe file.
test_warehouse_connection
ChatGPTRun a test query with the stored credentials and record the result. Overwrites the connection's stored status, last error and last-tested time with this result.
test_webhook
ChatGPTSend a test event to an outbound webhook endpoint to verify it is reachable and signatures can be validated. Each call sends another signed test event to the endpoint URL; the receiving system may process it like a real event.
trigger_account_event
ChatGPTRecord an event on an account (for example trial_ending, plan_changed, seat_limit_reached) and deliver it as a contact event to the chosen recipients: owners (default; falls back to admins when there is no owner), admins (includes owners), all members, or none (timeline only). Each delivery runs sync rules and sequence triggers with event.account.* properties. Pass eventId to make retries idempotent. Sequences triggered by the delivered contact events can email the recipient members, and those emails cannot be recalled.
trigger_subscriber_event
ChatGPTEmit a custom event for one subscriber, exactly as an integration or the public API would. This is the supported way to exercise event triggers, matching-field idempotency, branch conditions, and stop conditions end to end without waiting for real traffic. The event is recorded, sync rules apply, and matching event_received sequences enroll. Creates the subscriber if they do not exist. Use trigger_subscriber_events for several events on the same contact. Enrolled sequences can email the contact right away; events whose occurredAt is more than an hour old are stored as history and start nothing.
trigger_subscriber_events
ChatGPTEmit several custom events for one subscriber in order. Events are processed independently and sequentially, so a partial failure can still leave earlier events recorded. Recent events can enroll the contact in event_received sequences that email them; the contact is created if missing.
unarchive_sequence
ChatGPTRestore an archived sequence as a disabled draft so it can be reviewed before activation.
unpublish_landing_page
ChatGPTUnpublish a landing page and return it to draft status. Optional name, slug, or content updates are saved first. The public URL stops serving the page to visitors until it is published again.
unschedule_campaign
ChatGPTReturn a scheduled campaign to an editable draft. Removes its pending send and recurrence without permanently cancelling it, so it can be edited and scheduled again.
unschedule_push_campaign
ChatGPTMove a scheduled push campaign back to draft. Clears the scheduled time and cancels the queued send; the campaign must be sent or scheduled again to deliver.
unshare_campaign
ChatGPTRevoke the campaign's public view-in-browser link. The shared URL returns 404 immediately, and sharing again later mints a different URL - previously distributed copies stay dead. Returns revoked=false if no link was active.
unshare_template
ChatGPTRevoke the email's public view-in-browser link. The shared URL returns 404 immediately, and sharing again later mints a different URL - previously distributed copies stay dead. Returns revoked=false if no link was active.
unwatch_brand
ChatGPTStop watching a brand by its watch id (from list_watched_brands). This also withdraws the brand request with the same id. The brand stays in the gallery. Requires templates:write.
update_ab_test
ChatGPTUpdate A/B test settings. Campaign tests use testPercentage, testDurationMinutes, and winnerCriteria. During testing, duration is total minutes from the original start (a past deadline selects immediately), and audience changes queue a resize that preserves committed sends. Read pendingSampleUpdate and progress using get_ab_test; retry the same percentage after failure or discard a failed request with cancelSampleUpdate. The winning metric stays fixed once testing starts. Sequence tests use testType, winnerThreshold, winnerCriteria, and autoSelectWinner; changing live or already-used sequence settings requires confirmLiveChange. Provide at least one setting. On a running campaign test, a deadline already in the past selects the winner immediately and a larger sample sends test variants to more contacts.
update_ab_test_variant
ChatGPTUpdate an A/B test variant, including the email body of a sequence step whose nodeType is action_ab_test - that content cannot be edited through update_sequence_node or update_template, and a change meant for the whole step has to be repeated on every variant. Take abTestId and variantId from get_sequence.sequence.emails[].abTest.variants (or get_ab_test). Campaign variants are editable only in draft. Sequence variants can be edited after activity with confirmLiveChange, but earlier sends stay unchanged and combined results may no longer be accurate. Provide at least one of subject, previewText, html, or blocks. Use either html or blocks, not both. On an active sequence, the saved variant content is sent to contacts who reach the step after the edit.
update_account_health_insight
ChatGPTAct on one account health insight by id (from get_account_health): dismiss hides it for good, snooze hides it for snoozeDays (default 7, up to 90), resolve marks it fixed (it reopens if the next check still finds it), reopen brings back a snoozed or resolved one. Requires sequences:write.
update_account_health_settings
ChatGPTTurn the weekly account health check on or off and choose whether it drafts fixes. Pass only the fields to change. Checks never send email to subscribers or activate anything: autonomy draft_fixes only creates inactive draft sequences. Checks run every Monday at 05:00 UTC, before the Monday weekly report that carries the findings; the schedule is fixed. Who gets the findings is each person's own account_health notification preference (update_notification_preferences), not a workspace setting. Owner or admin only. Requires companies:manage. Enabled checks run weekly, and their AI agent can read pages on the company's website.
update_attio_settings
ChatGPTSet which Sequenzy lists sync into which Attio people-lists on an already-connected Attio integration, using the stored access token. The stored token is reused, so changing mappings does not require reconnecting or entering the Attio access token again. listMap is a full replacement — pass the complete desired map, {} to unmap every list, or omit listMap to leave mappings unchanged. Unmapped Sequenzy lists are not synced. Optionally set syncCompanyFromDomain. Provide at least one field. Idempotent: asking for the current state succeeds with changed: false. Does not backfill people already on a list; add-only, so unmapping does not remove anyone from Attio. Check get_attio_mapping first for Sequenzy list ids and live Attio list ids/slugs. Attio only. Requires the integrations:manage permission, which this connection does not include by default; without it, the same mapping is available in the dashboard at Settings -> Integrations -> Attio -> Map lists.
update_audience_sync
ChatGPTUpdate an audience sync's frequency or pause/resume it (isActive). Resuming or changing frequency controls the scheduled uploads of segment emails to the Meta custom audience.
update_campaign
ChatGPTUpdate a draft campaign's content, audience, sending identity, labels, Style > Format, delivery pacing, or recipient limit. Pass emailPreset to change Style > Format on native blocks without rewriting copy. sendTimeOptimization, sendTimeWindowHours and maxRecipients persist on the draft and are used when the campaign is later scheduled unless schedule_campaign overrides them. Send Time Optimization is not a company or sequence setting. It is campaign-only: audit with list_campaigns or get_campaign (sendTimeOptimization, sendTimeWindowHours, default 12h window). Change a draft with update_campaign, or apply it when calling schedule_campaign. Sequences use sendingWindow (allowed local hours/days), which is a shared gate, not per-subscriber predicted send times. If the campaign has an active share link, the public page shows the updated content immediately.
update_campaign_goal
ChatGPTUpdate a persisted email-campaign conversion goal, including its signal, attribution window, or active state. SMS campaigns are not supported.
update_campaign_variation
ChatGPTRename a campaign variation, replace its content (blocks or html, subject, previewText, emailTheme, fontFamily) or move it on the canvas (position). Content can only change once the variation is ready. To change it with AI instead, use edit_campaign_variation. To apply a section option from generate_campaign_variation_section_options, swap its replacement blocks into the variation's blocks by id and send the full blocks array here. Never changes the campaign email.
update_company
ChatGPTEdit company product info, brand context, the default email theme, reply-tracking settings, account-wide sending identity defaults, and defaultSubscriberListIds - which lists new untargeted contacts join. That field is the write path for Dodo Payments and live PostHog events, plus every other integration without per-integration targeting: null = every current and future list (not 'no lists'), [] = no list, [ids] = exactly those lists. PostHog history imports always create contacts without list memberships. fromEmail must use a verified sending domain; replyTo may be any valid mailbox. Missing sender/reply profiles are created automatically. Send fromName/replyToName on their own to rename the display name of the existing default profile without changing its address, or pair them with senderProfileId/replyProfileId (from list_sender_profiles) to rename a specific profile. Provide at least one editable field. Profile, branding, and AI-context fields need the company_profile:manage scope; the sending identity, reply-tracking, and defaultSubscriberListIds fields additionally need companies:manage. Changes to sender identity, reply-to, logo, colors and theme apply at send time to live campaigns, active sequences and transactional emails that use the company defaults.
update_conversation_status
ChatGPTOpen or close a conversation.
update_design_md
ChatGPTSave an edited design.md (full document from get_design_md). Only values you changed are written: a frontmatter value left as returned is not written and keeps its current behavior, a changed radius or heading font is pinned, and a changed layout token is written into the design direction ahead of its prose. Removing a key or section leaves it unchanged; an empty Voice or Design direction section clears it (an empty direction returns to brand-derived defaults). The Reference email section is read-only. Invalid values fail with line-numbered issues; unknown keys are ignored with warnings. Pass dryRun: true to preview changes and warnings without saving. Pass expectedVersion from get_design_md; on a 409 conflict, read again and reapply your edits. The saved logo, colors and theme apply at send time to live emails that have no theme of their own.
update_email_component
ChatGPTUpdate an email component's metadata or replace its blocks. Replacing blocks bumps the component version. Emails that already cloned this component keep the copy they were built with; the new version applies to emails built afterwards. Editing the component pinned as the default footer keeps its unsubscribe link enabled.
update_email_design_system
ChatGPTAdjust the company's email design system (partial update - only pass the fields to change). Affects every future AI-generated email and sequence enrichment. designCode tokens: kickerStyle (chip | letterspaced | none), titleAlignment (left | center), buttonShape (rounded | pill), dividerStyle (line | space), density (airy | compact), openerTreatments (subset of hero-image, hero-color, header-hero, editorial-masthead, title-led). compositionSpine: hero-led | editorial | product-spec. The adjustment is written into the company's emailDesignPrompt direction text (the single source of truth): the new identity's sentences are prepended and any custom prose the text carried is preserved below them. Pass reset: true to clear the direction text and return to brand-derived defaults. Free-form prose edits belong on update_company's emailDesignPrompt instead.
update_form
ChatGPTUpdate a saved signup form: rename it, retarget its audience, edit its copy, restyle its theme, or replace its content blocks (for example to remove unwanted blocks that render publicly). Read the current content via list_forms first when editing blocks. Changes apply immediately to the published form wherever it is embedded.
update_inbox_address
ChatGPTSet the inbox address to share, like support@support.acme.com, on one of the company's receiving domains (see list_receiving_domains; add one with add_receiving_domain), or go back to the default with reset. Any other address on that receiving domain also lands in the inbox. The address starts receiving once the receiving domain is verified (see customAddress.status in the result); inbox+{companyId}@inbound.sequenzy.com keeps working either way. Requires the companies:manage scope. Confirm the address with the user before changing it. Naming a verified sending domain that has no receiving domain yet creates a pending receiving domain on its inbound host and registers it with Amazon SES.
update_landing_page
ChatGPTEdit a landing page's name, slug, or full content. Provide at least one update field. On a published page, edits go live immediately and a new slug changes its public URL.
update_landing_page_domain_settings
ChatGPTUpdate or verify landing page domain settings. Omit landingPageId for the workspace domain, or provide it for a dedicated page domain. Dedicated domains must be removed explicitly before replacement. A new workspace domain replaces and releases the previous hostname with the hosting provider (Vercel); verify rechecks DNS and the provider and rewrites the stored status.
update_list
ChatGPTUpdate a subscriber list's name, description, or privacy. Only the provided fields are changed. A public list's name is shown to subscribers in the email preference center, and making a list public lets subscribers join it there.
update_notification_preferences
ChatGPTChange which account notifications Sequenzy emails the connected user for this company. Requires the companies:manage scope. Useful before a bulk import or a large migration, when per-signup notifications would otherwise flood the inbox, or to turn the Monday weekly report off (it is on by default only for the workspace owner; invited members set weekly_report to 'weekly' to receive it), or to opt in or out of the account health check's findings (account_health 'instant' or 'off'). Modes are 'off', 'instant' (one email per occurrence), 'daily' (one summary per day), and 'weekly' (the Monday report); 'daily' is only valid for new_subscriber, because a campaign finishes once and each form submit is its own lead, and 'weekly' is only valid for weekly_report; account_health accepts only 'off' or 'instant'. Instant form-submission notifications stop after 50 per workspace per UTC day. New-subscriber notifications already fall back to a daily summary automatically on high-volume days, and imports never trigger them at all.
update_push_campaign
ChatGPTUpdate a draft or scheduled push campaign. Only the fields you pass change. A scheduled campaign keeps its schedule. A scheduled campaign's queued send reads the saved content and audience at send time, so edits change what recipients' devices receive.
update_segment
ChatGPTUpdate a segment's name and/or filter rules. Use the same filters plus filterJoinOperator or nested root shapes as create_segment; providing filters or root replaces the segment's existing rules. Scheduled campaigns and audience syncs use the new membership, and segment-entered sequences on segments that reference this one can email new matches.
update_sender_profile
ChatGPTRename one sender (From) or reply-to profile in place, without changing which profile is the account default. Use this to standardize a display name across the several identities a mailbox may carry, e.g. renaming 'Viraj from SnapCount' to 'SnapCount'. Get IDs from list_sender_profiles. Only the display name changes: the address, its sending domain, and the account-wide default From/Reply-To selection are untouched, and existing campaigns and sequences pinned to this profile pick up the new name. To change which profile is the default instead, use update_company with senderProfileId/replyProfileId. A company cannot have two sender identities with the same name on one address, so a colliding rename is rejected and reports the ID already using that name. Requires the companies:manage scope.
update_sequence
ChatGPTUpdate an existing sequence: both its settings and its steps. Sequence-level settings live directly on this tool - name, description, labels, trigger (with its trigger-specific field), enrollmentMode plus enrollmentFieldPath, enrollmentPaused, userCancellable, stopCondition, sendingWindow, frequencyCapEnabled, bccEmails, and the sender/reply identity. This is the only way to change enrollmentMode after create_sequence, so use it to move a tag- or event-triggered sequence off the default 'unlimited' re-entry to 'one_time' or 'matching_field'. To target a specific existing step, use IDs returned by get_sequence. The emails/steps arrays edit email steps, smsSteps edits SMS steps, and subscriberUpdateSteps replaces the config of action_update_attributes steps. The emails/steps arrays reach action_email steps only: an action_ab_test step keeps its copy on the A/B test variants, so read variant blocks from get_sequence.sequence.emails[].abTest.variants and change each variant with update_ab_test_variant. To insert new linear steps, use insertSteps with an afterNodeId from get_sequence; omit afterNodeId only to append to an unambiguous linear tail. Deleting a step immediately moves parked recipients to its unique surviving successor, or completes them when no successor remains; inspect migratedRecipientCount and completedRecipientCount in the returned sequence. For active sequences, structural changes such as insertSteps or branch require confirmStructuralChange:true after the user confirms the live-flow impact. On an active sequence, saved content, sender and trigger changes apply to the next sends to real contacts.
update_sequence_goal
ChatGPTUpdate a persisted sequence conversion goal, including its signal, attribution window, or active state.
update_sequence_node
ChatGPTPatch one existing sequence node in place. Call get_sequence first, select sequence.nodes[].id, inspect nodeType/config, and pass that node's updatedAt as expectedUpdatedAt. This supports every stored sequence node type, including delays, email/SMS content, actions, conditions, branches without topology changes, webhooks, and trigger settings. Delay example: changes:{ delay:{ days:7 } }. For a direct text-forward email, use changes:{ emailPreset:'minimal' } on its action_email node; this changes only that linked email's Style > Format. To restyle one email, patch changes:{ emailTheme:{ colors:{ background:'#ffffff' } } } on its action_email node - that overrides only this step's linked email and leaves the company-wide theme alone. The update is type-aware and preserves fields you omit. It cannot change nodeType, managed linked-resource IDs, or graph topology; use edit_sequence_graph for structural work. It also cannot edit the copy of an action_ab_test step: that content lives on the A/B test variants (get_sequence.sequence.emails[].abTest.variants includes the blocks), so change each one with update_ab_test_variant. On an active sequence, set confirmLiveChange:true only after the user confirms the live behavior change. Existing recipients already waiting keep their scheduled timestamp; the new delay applies when recipients reach the node in the future. Saved email content goes out with the next sends of an active sequence and shows on the email's public share link.
update_sequence_nodes
ChatGPTAtomically patch multiple existing sequence nodes. Call get_sequence first and include each node's id plus its updatedAt as expectedUpdatedAt. Every patch follows update_sequence_node's type-aware rules. Either every node update commits or none do, making this the preferred tool for changes such as replacing all 5-minute delays with 7-day delays, or restyling several action_email nodes at once with changes:{ emailPreset:'minimal' } or changes:{ emailTheme:{ colors:{ background:'#ffffff' } } }, without changing the company theme. A node may appear only once. It cannot change node types or graph topology. On an active sequence, set confirmLiveChange:true only after the user confirms the live behavior change. Existing recipients already waiting keep their scheduled timestamps. Saved email content goes out with the next sends of an active sequence and shows on the email's public share link.
update_shopify_automation_settings
ChatGPTUpdate the connected Shopify store's browse-abandonment, cart-abandonment, and/or price-drop automation settings. Partial update: omitted sections are untouched, omitted fields within a section keep their current value, and passing null for a section resets it to the platform defaults (browse abandonment: on, 2h delay, 24h cooldown; cart abandonment: on, 1h inactivity, 24h cooldown; price drop: on, 5% minimum drop, 30-day viewer lookback, 7-day cooldown). Enabled sections fire browse, cart and price-drop events that start sequences emailing shoppers.
update_sms_number_settings
ChatGPTUpdate one SMS number's settings: the user-facing label, its brand prefix override, and/or link shortening. Use get_sms_settings to find the number ID. Omitted fields keep their value; pass an empty string to clear label or brandPrefix. Requires workspace-management permission. brandPrefix and linkShorteningEnabled change every later SMS sent from this number: the prefix recipients see and whether links become tracked short links.
update_subscriber
ChatGPTUpdate an existing subscriber's profile, phone, status, attributes, or tags. Names and phones are native profile fields - set them here rather than as custom attributes. Setting status to unsubscribed suppresses the contact from all marketing, deactivates list memberships, and cancels active sequence enrollments while preserving the record and suppression history. Added tags can start tag_added sequences that email the contact, and customAttributes replaces the whole custom-attribute map.
update_sync_rules
ChatGPTReplace the company's sync rules. Pass the FULL rule set (fetch with get_sync_rules first and edit it - this is not a partial update), [] to disable rules, or null to opt into the inherited SaaS/ecommerce platform preset. Each rule: { triggerEvent, actions: { addTags, removeTags }, conditions? }. Conditions support requiresTags, requiresNotTags, and purchasedProduct ({ tags?, collectionIds?, productTypes?, vendors? }) which matches products on commerce events - e.g. tag buyers of products carrying a given product tag. Tags the rules add on later events start tag_added sequences that can email those contacts.
update_tag
ChatGPTUpdate a tag's color. System tags cannot be updated.
update_template
ChatGPTUpdate an existing template. At least one of name, subject, previewText, html, blocks, labels, or isTemplate is required, and only those update fields are accepted. Bodies behind live sequence steps and transactional emails are overwritten too, so later sends and any public share link use the new content.
update_tracking_settings
ChatGPTUpdate the company's email tracking defaults: account-wide open and click tracking, narrower open and click defaults for Transactional API sends, unsubscribe tracking, opt-in strict bot filtering, the default attribution window, and automatic UTM tagging, plus the account-wide double opt-in requirement for new contacts. Applies to emails sent afterwards; already-sent emails keep the links they were rendered with. Transactional API defaults cannot enable an account-wide setting that is off, and an individual send may opt out again. Provide at least one field. Reply tracking (inbound email, reply domain mode, reply forwarding) is on update_company. The company tracking domain is managed with set_tracking_domain, verify_tracking_domain and remove_tracking_domain. Turning on double opt-in makes new contacts receive a confirmation email before they are subscribed.
update_transactional_email
ChatGPTUpdate a transactional email by ID or slug. At least one of name, enabled, subject, previewText, html, or blocks is required. Use html or blocks to replace the linked email body. Code-managed emails (managedBy: code) accept only name, enabled, and labels; disabling one makes send_email reject its trackAs sends. Saved content and enabled changes apply to every later send of this slug, including sends from the company's own applications.
update_warehouse_sync
ChatGPTChange a sync's name, query, mapping, cursor, schedule, lists or options, or pause/resume it with isEnabled. A changed query or cursor reads from the beginning again; unchanged rows are still skipped. Later runs overwrite contacts' mapped fields; enabling triggerAutomations or double_opt_in can start sequences or send confirmation emails.
update_web_push_settings
ChatGPTEnable or disable web push, or set the default notification icon. The first enable generates the workspace's VAPID keys; disabling keeps them so existing browser subscriptions stay valid. The site must serve /sequenzy-sw.js (importScripts of the hosted worker) and call sequenzy.subscribeToPush() from a click. Disabling stops web push delivery for push campaigns and sequence steps until re-enabled; defaultIconUrl replaces the icon on later notifications.
update_web_tracking_key
ChatGPTRename a web tracking key, replace its allowed origins, or revoke it. allowedOrigins REPLACES the whole list rather than appending, so include the origins you want to keep. Revoking with isActive: false stops events within about a minute while preserving the key value, so the customer can still find and remove the matching snippet from their site; use delete_web_tracking_key only once the snippet is gone. An empty allowedOrigins list lets any website send events with the key.
update_webhook
ChatGPTUpdate an outbound webhook endpoint's name, URL, subscribed events, or status (enabled/disabled). Providing events replaces the existing event list. Sequenzy disables an endpoint automatically after every delivery fails for 7 days (autoDisabledAt is set); enabling it or changing its URL clears that state.
upgrade_sending_domain_dns
ChatGPTRecommended, optional one-time upgrade of a verified sending domain to the current per-domain CNAME DNS records, for better deliverability and security, without removing it; it keeps sending on current records and sending is normally not interrupted at the switch. Once started it runs to the switch. Needs website.dnsUpgrade.status available; an older SES-only domain also needs a DMARC record (400 otherwise). Publish the returned dnsUpgrade.records CNAMEs next to the current records, removing nothing; the domain switches by itself about an hour after the required ones are public (verify_sending_domain checks now, no skip). Removing dnsUpgrade.oldRecords (listed beforehand as replacedRecords) after deleteOldRecordsAfter (8 days) is optional; each is marked removed once gone from public DNS.
upload_image_asset
ChatGPTUpload an image to the selected company's shared media library and return a public hosted URL plus a ready-to-insert Sequenzy image block. When an email needs a new image, call this before create/update campaign, sequence, template, or transactional tools, then place the returned imageBlock in the target blocks array. Provide the image as imageBase64 with a filename. PNG, JPEG, GIF, and WebP are supported up to 10MB. cropHeight with objectFit:'cover' provides a precise centered screenshot crop while displayWidthPercent keeps the image responsive. Anyone with the hosted URL can view the image. The returned URL is public: anyone with the link can load the image.
upsert_account
ChatGPTCreate or update an account by external ID. Attributes merge into the stored attributes (a null value deletes a key; set replaceAttributes to replace them all). Optional members are added in the same call. Use this to model companies, workspaces or teams so segments can filter on account.plan and emails can use {{account.name}}. The first account turns Accounts on for the workspace; it fails with a 409 error when contacts already use a custom attribute named account or account.*, which must be renamed first. Members with new emails are created as contacts, which can start contact_added sequences or double opt-in emails to them.
upsert_products
ChatGPTAdd or update products in your Sequenzy catalog, keyed by your own productId, for products your store or payment provider does not sync automatically. Sequenzy uses the catalog for product emails, recommendations and purchase-triggered sequences; it does not sell products or take payments. Marking a product back in stock can send back-in-stock emails to subscribers waiting for it.
use_campaign_variation
ChatGPTPut a ready variation's content in the campaign email (blocks, plus subject and preview text when the variation has its own). Draft campaigns only. If the email's current content is not already a variation, it is saved first as a new variation named "Before <label>" and returned as savedPrevious, so the previous version is never lost. Translations are re-derived from the new content. If the campaign has an active share link, the public page shows the new content immediately.
use_sequence_email_variation
ChatGPTUses a design variation of a sequence email (see list_sequence_email_variations). Saves a ready variation's design (blocks, theme and font) into the email, which keeps its own subject and preview text. With scope all, every other email of the sequence also takes the variation's style exactly (theme, font and the style of each kind of block) while keeping its own words; emails written in HTML keep theirs. Returns emails[] with status (changed or unchanged), saved, summary and error per email. dryRun returns the result without saving. On an active sequence, saved changes go out with the next sends. An email saved elsewhere meanwhile comes back with saved:false and an error instead of being overwritten.
verify_receiving_domain
ChatGPTCheck a receiving domain's DNS now instead of waiting for the automatic check. For a domain added with add_receiving_domain, the first successful verification turns Inbox on (replyTracking.inboundEmailEnabled); domains from an older reply setup or created by update_inbox_address leave it unchanged. Owner or admin only. A failed check on a verified domain marks it failed, and new reply addresses fall back to Sequenzy's shared address until it is fixed.
verify_sending_domain
ChatGPTRun a fresh DNS check for a configured sending domain and return DNS verification separately from sending readiness. When readyToSend is false, read readiness.reason. Receiving mail (inbox addresses and replies) is checked on receiving domains instead: see verify_receiving_domain. Saves the new status: a failing check can unverify the domain, and a sending-ready domain can become the company's default sender, repointing saved emails that used a built-in sender.
verify_tracking_domain
ChatGPTCheck the company tracking domain's CNAME and HTTPS certificate now instead of waiting for the automatic check. Returns verified, a message with the next step, and the tracking domain status. Queries public DNS and Cloudflare; a failed check can mark a verified tracking domain failed, so new emails use the shared Sequenzy tracking domain.
watch_brand
ChatGPTFollow a brand's marketing emails, such as a competitor's newsletters and promotions, in Sequenzy's public email gallery. Pass its website or domain. Gallery emails are the ones a brand sends to its public mailing list, which Sequenzy signs up to like any reader; no one's private mailbox is read. A brand already in the gallery is followed at once (status available) and its emails can be read with list_watched_brand_emails; any other brand is suggested for the gallery and its emails show up once it is added. New emails arrive a few hours after they are sent. Watching again keeps the one watch (a new note replaces the old) and returns created false. A company can keep up to 50 watches and gallery suggestions together and cannot watch its own website. Requires templates:write.
