email_add_automation_steps
ChatGPTAppend steps to the END of an automation or one of a branch's lanes (allowed while active — in-flight runs are unaffected and will continue into the new steps). This is how 100-step evergreen automations are authored incrementally. Pass parentStepId + laneKey (e.g. 'yes'/'no', a multi arm key, or 'else') to target a lane; omit both for the top level. To insert BETWEEN existing steps, pause first and use afterPosition (interpreted within the target lane).
email_add_suppression
ChatGPTManually suppress an address. A manual suppression (default) blocks ALL sends to it in this project; unsubscribe blocks marketing email (category lifecycle) only (transactional receipts/resets still deliver).
email_add_translation
ChatGPTAdd a locale translation of a template as a new draft version. The send path delivers each contact the version matching their locale attribute, falling back to the base language when a translation is missing. Translate the copy in the company's voice (don't machine-translate blind — keep subjects short per language). Publish it like any version; a translation never becomes the template's base 'current' version.
email_backfill_missed_enrollments
ChatGPTEnroll the contacts who qualified while an automation was PAUSED. Events keep being recorded when an automation is off, so the people it missed are recoverable — this is the catch-up after pausing to fix a template or filter. ALWAYS dryRun first and show the human the counts: contacts whose exit event arrived after their trigger are skipped (they resolved during the pause — enrolling them would chase a customer who already converted), and the automation's own re-enrollment/cooldown/suppression guards still apply. since is required and should be the moment it was paused; there is no 'everything', because replaying an hour-long chase days late is noise. Resume the automation before running for real.
email_bootstrap_company
ChatGPTSet up a company's email in one call: materialize the starter templates each pack needs, PUBLISH the versions it just creates (compile-checked, battle-tested starters), and create the packs' automations — ALWAYS PAUSED. Nothing sends: enabling each automation stays a separate human-confirmed setAutomationStatus. Idempotent: re-running skips templates and packs already installed, so you can add a pack later without duplicates. Confirm the archetype with the human (listSequencePacks) and set the brand first (updateBrand) for on-brand emails.
email_cancel_scheduled_email
ChatGPTCancel a still-SCHEDULED send before it goes out (drops its worker job). Fails once the message has left the scheduled state.
email_create_automation
ChatGPTCreate an event-triggered automation (welcome, weekly engagement, win-back). ALWAYS created paused — test with emitContactEvent, then enable via setAutomationStatus on the human's explicit OK. Attribute-routing: create N automations on the same trigger with different filters + priorities; exclusive=true means first-match-only. triggerFilter accepts a flat array (all AND) OR a nested {op:'and'|'or', conditions:[...]} group for OR logic. SEGMENT-ENTRY trigger: set triggerEvent to "$segment_entered" and triggerFilter to [{path:'event.properties.segmentId', op:'eq', value:'<segmentId>'}] to enroll a contact the moment their attributes make them newly match that segment (still throttled/suppressed — no blast). SCHEDULED trigger: set triggerEvent to "$scheduled" plus triggerSchedule ('daily'|'weekly'|'monthly') and a triggerFilter — a sweep re-evaluates the filter across the audience on that cadence and enrolls whoever matches. $segment_entered is EDGE-triggered (fires on a transition, so it never reaches contacts already in the state); $scheduled is LEVEL-triggered, which is what list hygiene needs. A $scheduled automation REQUIRES a filter and should set allowReenrollment with a cooldown. ENGAGEMENT filters (usable in triggerFilter and branch filters): contact.engagement.emailsSinceEngaged, .daysSinceEngaged, .emailsReceived, .openCount, .clickCount, .openRate, .clickRate (percent), .lastOpenedAt, .lastClickedAt, plus contact.subscriptionStatus. Timestamps compare with within_days / older_than_days (a NUMBER OF DAYS); both are FALSE when the timestamp is null, so use daysSinceEngaged for the never-engaged case — it falls back to days since the first email, which is what stops a sunset rule catching new subscribers. STEP TYPES: 'send' (default — templateSlug), 'delay' (a standalone wait — {delaySeconds} is the pause before the next step; stack them, put one at the end, reorder like any step), 'wait_for_event' (pause until a contact_event arrives or timeoutSeconds elapses), 'branch' (see below), 'set_attribute' (merge {attributes} and/or {addTags}/{removeTags} — tags ARE segment membership), 'webhook' (POST the payload to a public {url}), 'unsubscribe' (opt the contact out of ALL marketing email — transactional still delivers; it ENDS the run as unsubscribed, so no 'exit' step is needed after it, and it is a logged no-op when the project's open/click tracking isn't confirmed on), or 'exit' (end the run here, optionally labeled). Prefer a 'delay' step for waits; a delaySeconds on any other step type is auto-split into a delay step before it. BRANCHES own lanes of child steps that CONVERGE after the branch: yes/no = {filter, yes:[steps...], no:[steps...]} (an empty lane skips straight past); multi = {branches:[{key, label?, filter, steps:[...]}], elseSteps:[...]} — first matching arm wins, everyone else takes the else lane. End a lane early with an 'exit' step; otherwise its contacts continue after the branch. Lanes nest at most two levels. The legacy gate shape {filter, ifMatch, ifNoMatch} ('continue'/'exit') still works.
email_create_domain
ChatGPTRegister a sending domain with the provider (use a SUBDOMAIN like mail.example.com, never the root). Returns the DNS records (SPF/DKIM) plus a recommended DMARC record the human must add at their DNS host, then verifyDomain once propagated.
email_create_project
ChatGPTCreate a new project (company) in the workspace. Optionally store the company's website URL. Creates empty Canon scaffolding; does not fetch the website or populate the brand kit. Refused when the caller is clamped to a single company, such as the in-app chat inside a company, and when the workspace is at its tier's company limit.
email_create_segment
ChatGPTCreate a named segment from a filter over contact attributes ⊕ tags (paths like 'contact.attributes.plan' or bare attribute keys; ops eq/neq/exists/not_exists/in/gt/lt/contains). Member count is primed on create. Use the segment id as an automation trigger via createAutomation's triggerSegmentId.
email_create_sender
ChatGPTCreate a sender identity (from name + address) on a VERIFIED sending domain. Refused while the domain is unverified. The first sender becomes the project default.
email_create_template
ChatGPTCreate a template (react.email TSX, imports limited to react + @react-email/components, one default export) with a draft v1. Category decides who an unsubscribe blocks: 'transactional' (receipts, resets — still delivered to unsubscribed contacts) vs 'lifecycle' (marketing email — blocked once a contact unsubscribes). Every send carries one-click unsubscribe headers either way. Use the COMPANY's brand from the project brief. For the 8 standard emails, pass starter to begin from a brand-filled baseline instead of authoring from scratch — then rewrite the copy in the company's voice. Then renderTemplate to iterate.
email_create_webhook_endpoint
ChatGPTRegister an HTTPS endpoint to receive email events (delivered, bounced, opened, …) so the customer's system does not have to poll. Returns the endpoint WITHOUT its signing secret — the operator copies that from the dashboard.
email_delete_automation
ChatGPTArchive an automation (paused only; running contacts' runs are canceled). An explicit human decision.
email_delete_contact
ChatGPTPermanently delete one contact (a data-deletion request). Removes the profile, attributes and tags; the message log keeps its rows. Does NOT suppress the address — a later event or send recreates the contact, so use addSuppression as well when the person asked not to be emailed.
email_delete_domain
ChatGPTDelete a sending domain: removes it from the project (its senders go with it) AND from the provider account unless another project still uses it. Sends from it fail afterwards. Refused while the project default sender is on it and other senders exist elsewhere.
email_delete_segment
ChatGPTDelete a segment. Automations already triggered by segment-entry keep their enrolled runs; new enrollments stop. An explicit human decision.
email_delete_sender
ChatGPTDelete a sender identity. Refused for the default sender while other senders exist (promote another first). Templates pinning it fall back to the project default.
email_delete_template
ChatGPTArchive a template (soft delete; message history keeps pointing at it). Refused if an enabled automation references it. An explicit human decision.
email_delete_webhook_endpoint
ChatGPTDelete a webhook endpoint permanently, along with its delivery log. To pause delivery instead, set enabled: false.
email_duplicate_automation
ChatGPTClone an automation and all its steps into a new PAUSED automation (delays, prop overrides, A/B variants, send windows preserved). Useful to fork a proven automation for a variant or a new segment.
email_emit_contact_event
ChatGPTManually emit a contact event — the way to TEST-DRIVE automation triggers end to end (enrollment happens exactly as with API events). Production events come from the company's app via POST /api/v1/events.
email_get_automation
ChatGPTFull automation detail: config + ordered steps + run counts per status. Each step carries waiting — how many runs are parked on it right now, when the next one is due, and how many are overdue.
email_get_automation_metrics
ChatGPTPer-step and per-variant funnel for an automation: sent, delivered, opened, clicked, bounced (from message + event data). Keyed by step, with an A/B winner readout that calls a leader only once each arm has enough volume and the gap is material.
email_get_brand
ChatGPTRead the company's brand kit (logo, colors, fonts, voice, sign-off, footer address, links) and website. Call before authoring or reviewing any email so it uses the COMPANY's identity, not the app's. What the company DOES lives in its Canon — read that with the knowledge tools.
email_get_connection_status
ChatGPTSending-setup status for the scoped company: provider connection (masked key), domains with per-record DNS state, senders, webhook registration, kill switch, and settingsUrl — the sending settings page where the operator connects a provider or the platform they are migrating off, adds domains and senders, and mints API keys. Call before any setup step.
email_get_contact
ChatGPTOne contact: profile + suppression state + recent events + recent messages.
email_get_email_metrics
ChatGPTAggregate delivery/engagement metrics for a period (default 7 days): totals + rates, grouped by template and by day. complaintRatePct is complaints ÷ fbl_delivered (mail to Yahoo/Outlook and the other inboxes that report spam — Gmail and iCloud never do); at 0.08% or above, stop and investigate.
email_get_email_revenue
ChatGPTRead-only revenue attribution from the independently operated PostHog API. Currently unavailable while website analytics is disabled: returns configured:false without calling PostHog. When enabled, reads the company's connected PostHog project, plus the per-utm_campaign breakdown and total revenue for the same window. Attribution is LAST touch: a purchase is credited to the session an email link opened, so revenue landing in a later session is not counted — say so when quoting the number. Returns configured:false when PostHog or the revenue event isn't set up.
email_get_message
ChatGPTOne message + its full event timeline (sent → delivered → opened/clicked, bounces).
email_get_metrics_trends
ChatGPTDay-by-day metric trends from the pre-aggregated daily rollup (email_daily_stats), with the most recent days recomputed live so today and late-arriving bounces are included — cheaper than scanning the message log for long ranges. Each day is a send-day cohort: an event counts on the day its message was SENT, not the day it arrived. Returns a per-day series (sent/delivered/fbl_delivered/opened/clicked/bounced/complained/unsubscribed) plus totals. Complaint rate = complained ÷ fbl_delivered (mail to Yahoo/Outlook and the other inboxes that report spam; Gmail and iCloud never do), never ÷ sent. Default 30 days.
email_get_onboarding_steps
ChatGPTThe guided setup's ten steps for the scoped company, each with its address (1.1–3.5), title, phase and whether it is done — the same list the operator sees in the dashboard. Call it before describing progress or picking what to do next.
email_get_optimization_plan
ChatGPTRanked, evidence-backed action feed for a company's email — deliverability risks (complaints/bounces), setup gaps (unverified domain, kill switch on), conversion opportunities (A/B winners ready to promote, zero-open templates), and hygiene (stale drafts). Ground optimization answers in this. Each action carries evidence; the promote-winner action carries the exact promoteAbWinner call to apply it.
email_get_project_settings
ChatGPTRead the sending guardrails: kill switch (sendsPaused), daily send cap, UTM tagging, default locale, and how many emails went out today — read this before changing any of them.
email_get_queue_health
ChatGPTBackground-job queue health for the whole workspace: pending jobs due now, age of the oldest pending job, in-flight count, and dead-letter count. A high or growing pendingDueNow / oldest age means the worker is wedged (e.g. it can't reach the DB) and scheduled/automation sends are backing up. Org-scoped.
email_get_source_flow
ChatGPTRead one pulled flow's steps in order — waits, emails and their subject lines, branches. Use it to restate what a flow does today before proposing our version, and to lift subject lines and cadence rather than reinventing them. Honour partial: a partial flow's steps are incomplete and you must say so instead of presenting them as the whole flow.
email_get_template
ChatGPTFull TSX source + subject + variables of a template version (default: latest).
email_import_contacts
ChatGPTBulk-import contacts when migrating a company in (CSV rows parsed to entries). Max 500 per call; repeat for more. Attributes merge on existing contacts.
email_import_suppressions
ChatGPTBulk-import suppressions when migrating a company in (from the old provider's suppression export or a CSV). Run BEFORE the first real send — re-mailing known bounces/complaints damages a new domain's reputation. Each imported address stops receiving mail from this project at once, an existing unsubscribe row is raised to manual, and any automation run in progress for the address ends; removing the suppression later does not restart those runs. Import a source's bounces/complaints as manual with the source's own label in note (manual blocks the same sends, and unlike a complaint it can be removed). Max 1000 per call; repeat for more.
email_list_automation_runs
ChatGPTPer-contact runs of an automation: state, current step, next send time.
email_list_automations
ChatGPTList the company's automations with status, trigger, and step count.
email_list_contacts
ChatGPTList contacts (newest first). Filter by attribute equality or by tag when needed.
email_list_events
ChatGPTEvent catalog: the contact-event names this project has received, with volume and last-seen — the vocabulary automations can trigger on. Use before designing a trigger to confirm the exact event name (and catch typos).
email_list_projects
ChatGPTList the operator's projects (one project = one company) with status and website. Use first when the operator asks something open-ended, and before any company-scoped work — it returns the projectId every company-scoped tool needs.
email_list_segments
ChatGPTList the company's contact segments (saved filters) with their persisted member counts.
email_list_senders
ChatGPTList the company's sender identities.
email_list_sequence_packs
ChatGPTCatalog of business archetypes (saas / ecommerce / newsletter-media / marketplace) and the packs each installs (a pack is a starter set of paused automations). Call this first to confirm the archetype and pack selection with the human before bootstrapCompany.
email_list_source_flows
ChatGPTList the flows we pulled from the platform the company is leaving. Call this BEFORE proposing an email automation programme for any company that has connected a source — designing from scratch over the top of eleven existing flows is the failure this exists to prevent. Returns names, status, trigger and step counts; use getSourceFlow for the steps of one.
email_list_suppressions
ChatGPTList suppressed addresses with reason (bounce/complaint/manual/unsubscribe/invalid). invalid = verified undeliverable by MillionVerifier before we ever sent.
email_list_template_versions
ChatGPTVersion history of a template (status, variant, author, created).
email_list_templates
ChatGPTList the company's templates with publish state.
email_list_webhook_deliveries
ChatGPTRecent delivery attempts for one endpoint — status, response code, and the first 2 KB of the customer's own response body. The first thing to read when an event 'never arrived'.
email_list_webhook_endpoints
ChatGPTList the customer's webhook endpoints, their subscriptions, and their recent delivery health.
email_list_webhook_event_types
ChatGPTThe event names a webhook endpoint can subscribe to. Use before creating or updating an endpoint — an unknown name is refused.
email_move_automation_step
ChatGPTSwap a step with its LANE neighbor (direction 'up' = earlier, 'down' = later; moves never cross lanes). Only while paused — in-flight runs compute their next step by position. Moving a branch carries its lanes with it.
email_pre_launch_check
ChatGPTRead-only pre-launch checklist for an automation: templates published, verified sending domain, whether the trigger event has ever fired. Run this BEFORE setAutomationStatus to catch issues without flipping it live.
email_preview_automation
ChatGPTDry-run the automation: render every send step with a sample contact (its example props ⊕ any props you pass) and return subject + text (+ html on request) and a 15-minute previewUrl per email (anyone with the link can view it), plus the humanized timeline. Saves temporary HTML snapshots and creates new bearer links on each call. Nothing sent — this is how you show a human what an automation will actually look like before enabling it.
email_promote_ab_winner
ChatGPTPromote a called A/B winner on an automation step: collapse the split to the winning variant so every contact gets it (reversible with setAbTest). Re-verifies the winner at apply time and refuses if the arms no longer clear the volume + gap thresholds. Relay the human's explicit decision — the plan recommends, the operator decides.
email_publish_template_version
ChatGPTPromote a version to live: what the API and automations resolve for this template. Only on the human's explicit OK after a test send. Publishing freezes the version (edits create a new draft).
email_refresh_segment_count
ChatGPTRecompute a segment's member count now by evaluating its filter against current contacts (up to 50k scanned).
email_refresh_source_flows
ChatGPTRe-read a connected source. Use it after the operator fixes a missing scope on the source platform, or when they've changed their flows since the first pull. Replaces the snapshot: flows deleted on their side disappear here too.
email_register_webhooks
ChatGPTPoint the provider's delivery/bounce/complaint/open/click events at our webhook endpoint so metrics and auto-suppression work. Reuses an existing platform webhook when available. Setup is not done without this.
email_remove_automation_step
ChatGPTRemove a step by position. Removing a branch removes ALL its lanes' steps. Only while paused, and only when no in-flight run points at it or any lane step being removed.
email_remove_suppression
ChatGPTRemove a suppression so the address can receive mail again. COMPLAINT suppressions are never removable. Exceptional and human-decided — reactivating a bounced address risks the domain's reputation.
email_render_template
ChatGPTCompile + render a template version with example (or given) props. THE authoring inner loop — returns html/text/subject and a 15-minute previewUrl on success (anyone with the link can view it). Open previewUrl in the client browser panel when available. Returns verbatim compile/render errors on failure. Saves a temporary HTML snapshot and creates a new bearer link on each call. Nothing is sent.
email_replay_webhook_delivery
ChatGPTRe-send one past delivery to its endpoint — after the customer fixed whatever made it fail. Same payload and same webhook-id, so a receiver that already processed it dedupes it away. Refused while the delivery is still pending or in flight. Ids come from listWebhookDeliveries.
email_reschedule_email
ChatGPTMove a still-SCHEDULED send to a new time (ISO or natural language). Fails once the message has left the scheduled state.
email_restyle_template
ChatGPTRe-skin a template to the company's CURRENT brand kit as a new draft version — colors, fonts, logo, sign-off, and footer all refresh at once. Works automatically on starter-derived templates (they carry a self-contained BRAND token block); hand-authored templates are refused with guidance to rewrite via getBrand + updateTemplate. Never touches the published version; renderTemplate + publish afterwards.
email_search_messages
ChatGPTSearch the message log: by recipient, template slug, status, source, date range. Returns newest first.
email_send_email
ChatGPTSend one email to ONE primary recipient using a published template (suppression-checked, logged, rate-capped like any send). cc/bcc carbon-copy the SAME message — not a way to blast a list; for broad sending use an automation. Supports custom headers, {name,value} tags, and scheduling (ISO or natural language like 'in 2 hours').
email_send_template_test
ChatGPTRender a template version (draft or published) and send it to a real inbox with example (or given) props. Ask the human to check rendering (Gmail + dark mode) before publishing.
email_send_test_email
ChatGPTProve the plumbing end to end: send a minimal test email (no template) from the default sender to the given address. Ask the human to confirm receipt (and check spam).
email_set_ab_test
ChatGPTAttach or clear an A/B split on a step: weighted template VERSIONS (create variant versions with updateTemplate variantKey + publish them first). Assignment is deterministic per contact-run.
email_set_automation_status
ChatGPTEnable or pause an automation — an explicit human decision you relay, never originate. Enabling validates every referenced template has a published version and wakes parked runs.
email_set_daily_send_cap
ChatGPTSet an OPTIONAL daily send cap that tightens below the provider plan's own daily limit (emails/day across ALL sources — API, automations, copilot). 0 = no extra cap, rely on the provider plan. Use as a guard rail on a fresh domain; the plan limit always applies on top. Read the current value from getConnectionStatus.
email_set_default_locale
ChatGPTSet the project's default locale — the fallback used to pick a template translation when neither the send call nor the contact's locale attribute carries one. Tag like 'fr' or 'pt-BR'; pass null to clear (sends fall back to the base template language). A missing translation never blocks a send — it falls back to the base version.
email_set_default_sender
ChatGPTMake a sender the project default (used when a template has no sender).
email_set_sends_paused
ChatGPTKill switch: pause or resume ALL sending for this company (API, automations, copilot). An explicit human decision — only call when the operator clearly asked for it.
email_set_utm_tagging
ChatGPTConfigure auto UTM tagging: params appended to every external link in outgoing emails (Google Ads-style, set once and forget). Tagging is ALREADY ON by default (utm_source=email, utm_medium=email, utm_campaign={{automation}}, utm_content={{template}}-{{step}}, utm_term={{variant}}) — call this only to change those params or to switch tagging off. Values may embed {{automation}}, {{step}}, {{template}}, {{variant}}, {{source}} — resolved per send, slugified, omitted when empty; existing URL params always win. Pass enabled=false to turn tagging off. Read the current config from getConnectionStatus.
email_sync_automation_step_props
ChatGPTBulk-set props_overrides across many SEND steps in one call, addressed by position — the write side of a content pipeline that generates per-edition props (e.g. an 80-week automation, one send a week). merge=false (default) replaces each step's overrides; merge=true shallow-merges. Validates all positions first (must exist + be send steps); while active, refuses positions any in-flight run has reached (pause to edit those). Non-send positions are rejected.
email_test_webhook_endpoint
ChatGPTQueue a synthetic webhook.test delivery so the operator can confirm signature verification works before real mail goes out. The endpoint must be subscribed to webhook.test.
email_unpublish_template
ChatGPTTake a published template back out of service: clears its live version and returns it to draft, so every send refuses with template_not_published until it is published again. Use when a template went live before it was ready — this is NOT deleteTemplate, nothing is archived and republishing restores it. Refused while an active automation sends this template; pause those first.
email_update_automation
ChatGPTUpdate an automation's trigger, filter, priority, exit event, or name. Trigger/filter changes affect FUTURE enrollments only. triggerFilter accepts a flat array (all AND) OR a nested {op:'and'|'or', conditions:[...]} group — the same shapes createAutomation takes — so OR filters can be updated, not just created. Pass null to clear. triggerSegmentId retargets the automation at a segment (expands to the $segment_entered trigger) — don't combine it with triggerEvent/triggerFilter. Steps are edited with addAutomationSteps / updateAutomationStep / removeAutomationStep.
email_update_automation_step
ChatGPTEdit one step by position. delay step: delaySeconds (the wait). Send steps: template, props, send window, per-step subject/previewText overrides (null clears back to the template's). Non-send steps: their config — wait_for_event (eventName/timeoutSeconds), legacy-gate branch (filter/ifMatch/ifNoMatch), yes/no branch (filter), multi branch (branches — may not orphan a lane that still has steps), exit (label), set_attribute (attributes/addTags/removeTags), webhook (url/method). A wait belongs on its own delay step — delaySeconds is only editable on a delay step. Step TYPE and a branch's kind are immutable — to change them, remove the step and add a new one. While active, only steps NO run has reached yet can be edited; otherwise pause first. The one exception is skipped (the debug switch — a skipped step is walked past without sending, POSTing, writing attributes or serving its wait): sent on its own it is allowed on a live automation with contacts parked on the step.
email_update_brand
ChatGPTUpdate the company's structured brand kit. A provided section (logo/colors/fonts/voice/signOff/footerAddress/socialLinks) wholly replaces the stored one; omitted sections stay untouched — to clear a section, pass it empty. Persist inferred brand tokens here so every future email stays consistent.
email_update_segment
ChatGPTUpdate a segment's name, description, and/or filter. A filter change recomputes the persisted member count and moves who future segment-entry automations enroll.
email_update_sender
ChatGPTUpdate an existing sender's display name and/or reply-to address. The from-address is NOT editable (changing it needs domain re-validation — create a new sender instead). Pass replyTo: null to clear it.
email_update_template
ChatGPTCreate a NEW draft version of a template (published versions are immutable). Omitted fields carry over from the latest version. name and category are NOT versioned: they change the template in place, immediately, for every live send — switching category changes whether an unsubscribe blocks those sends. Confirm a category change with the user first.
email_update_template_meta
ChatGPTThe 'just fix the subject' path — no new TSX. Subject and preview-text edits create a new version and are AUTO-PUBLISHED when the template is already published, so the change goes out on the next send (unlike updateTemplate, which leaves a draft). The sender updates in place. Confirm the new subject with the user first when the template is live.
email_update_webhook_endpoint
ChatGPTChange a webhook endpoint's URL, subscriptions, or enabled state. eventTypes REPLACES the list rather than merging. Enabling also clears the failure streak.
email_upsert_contact
ChatGPTCreate or update a contact (attributes shallow-merge; tags REPLACE the set when given). Attributes drive automation filters (e.g. contact.attributes.city) and template personalization; timezone (IANA) controls send windows. Tags are labels a segment/filter matches via contains on path contact.tags.
email_verify_domain
ChatGPTTrigger provider verification for a sending domain and return per-record status plus a DMARC advisory (DMARC never blocks verification). DNS can take minutes to hours to propagate — re-check later rather than re-creating.
