# Meet the Founders
Source: https://docs.migma.ai/about/meet-the-founders

Meet Migma founders Adam and Liam Lababidi, Swedish entrepreneurs building AI-powered tools for modern marketing teams from Stockholm and Barcelona.

## The Lababidi Brothers

Adam and Liam Lababidi (La-ba-bee-dee) are Swedish entrepreneurs building AI-powered tools for modern marketing teams. Based between Stockholm and Barcelona, they bring proven experience in scaling tech products globally.

<CardGroup>
  <Card title="Adam Lababidi" icon="user">
    **CEO - AI/Backend**

    Specializes in AI systems and scalable infrastructure
  </Card>

  <Card title="Liam Lababidi" icon="user">
    **Vice CEO - Frontend & Design**

    Focuses on user experience and product design
  </Card>
</CardGroup>

***

## Background

### Previous Success: PaidTabs

Before Migma, the brothers founded **PaidTabs**, a platform serving thousands of musicians worldwide:

* **\$1M ARR** (bootstrapped)
* Scaled globally without external funding
* Featured on **SVT** (Swedish National Television)

### Entrepreneurship Programs

**STING** - Selected for Sweden's leading startup accelerator program

**EWOR** - European entrepreneurship network

**Swedish Entrepreneurs** - Active in the Scandinavian startup ecosystem

***

## Why Migma?

After experiencing the frustrations of traditional email marketing tools, they built Migma to make email creation:

* **Fast** - Create emails in seconds with AI
* **Easy** - No coding or design skills needed
* **Smart** - AI that learns your brand
* **Affordable** - Fair, transparent pricing

***

## Our Values

<CardGroup>
  <Card title="User-First" icon="heart">
    Every decision starts with "How does this help our users?"
  </Card>

  <Card title="Innovation" icon="lightbulb">
    Constantly pushing boundaries for better solutions
  </Card>

  <Card title="Transparency" icon="eye">
    Honest pricing, clear docs, no hidden fees
  </Card>

  <Card title="Quality" icon="star">
    From design to infrastructure, quality is non-negotiable
  </Card>
</CardGroup>

***

## Location

Based between **Stockholm, Sweden** and **Barcelona, Spain** - combining Scandinavian innovation culture with creative Mediterranean energy.

***

## Connect

<CardGroup>
  <Card title="Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Join our community
  </Card>

  <Card title="Twitter/X" icon="twitter" href="https://x.com/migma_ai">
    Follow for updates
  </Card>

  <Card title="LinkedIn" icon="linkedin" href="https://linkedin.com/company/migmaai">
    Professional updates
  </Card>
</CardGroup>

### Founders

**Adam Lababidi**

* [LinkedIn](https://www.linkedin.com/in/adam-lababidi-3688021b5/)
* [Twitter/X](https://x.com/TheDreadCEO)

**Liam Lababidi**

* [LinkedIn](https://www.linkedin.com/in/liam-lababidi-b56b8a1a8/)

***

## Work With Us

<AccordionGroup>
  <Accordion title="Careers" icon="briefcase">
    We're building a world-class team. Check opportunities at [migma.ai/careers](https://migma.ai/careers)
  </Accordion>

  <Accordion title="Partnerships" icon="handshake">
    Interested in integrations, affiliates, or co-marketing? Contact: [hello@migma.ai](mailto:hello@migma.ai)
  </Accordion>

  <Accordion title="Press & Media" icon="newspaper">
    For press inquiries or speaking opportunities: [press@migma.ai](mailto:press@migma.ai)
  </Accordion>
</AccordionGroup>


# Email Deliverability Best Practices
Source: https://docs.migma.ai/advanced-features/email-deliverability-best-practices

Improve email deliverability by authenticating your domain, protecting consent and list quality, reducing complaints, and testing messages before sending.

Email deliverability is shared between your sending domain, audience quality, message content, and mail provider. Migma helps with domain setup, validation, suppression, rendering checks, and preflight review, but inbox placement is never guaranteed.

Use this page as an operating checklist before important sends.

<Info>
  Migma is built for permission-based email. Do not use Migma for cold outreach, purchased lists, scraped contacts, or people who did not ask to hear from you. See [Permission-based sending](/get-started/what-you-can-send).
</Info>

## Delivery Readiness

Check these four areas before any high-volume or important campaign.

| Area | Ready when | If not ready |
| - | - | - |
| Permission | Recipients clearly opted in for this kind of email | Review [sending rules](/get-started/what-you-can-send) and narrow the audience |
| Domain | SPF, DKIM, DMARC, and MAIL FROM are verified | Finish [Add Sending Domain](/sending-domains/add-domain) and resolve [Verification Issues](/sending-domains/verification-issues) |
| Audience | Bounces, complaints, unsubscribes, invalid contacts, and risky addresses are excluded | Clean the list with [Deliverability & Validation](/audience/deliverability) and [Suppression List](/sending-domains/suppression-list) |
| Email | Links, rendering, content, compliance basics, and spam-risk signals pass review | Run [Email Preflight](/email-editor/email-preflight), fix red items, and re-check |

***

## Start With Consent

Mailbox providers look at recipient behavior. People who expected your email are more likely to open, click, reply, or ignore it without complaint. People who did not expect it are more likely to bounce, unsubscribe, or mark it as spam.

Before importing or sending to a list, confirm:

* Contacts opted in through a form, checkout flow, account setting, event registration, or another clear consent path.
* The email type matches the consent they gave, such as newsletter, lifecycle, product update, or transactional.
* Suppressed, bounced, complained, and unsubscribed contacts remain excluded.
* Segment criteria match the message. Do not send broad campaigns to people with weak or stale intent.

<Warning>
  Purchased, rented, scraped, guessed, or cold outreach lists damage domain reputation and are not allowed in Migma.
</Warning>

Related: [GDPR newsletter consent](/compliance/gdpr-newsletter-consent), [CAN-SPAM checklist](/compliance/can-spam-checklist), [CSV Upload](/audience/csv-upload).

***

## Authenticate Your Sending Domain

Authentication proves that your email provider is allowed to send mail for your domain. Major inbox providers expect authenticated mail, and bulk senders should treat SPF, DKIM, and DMARC as required.

| Record | What it does | Where to set it up |
| - | - | - |
| SPF | Authorizes sending servers for your domain | DNS provider |
| DKIM | Signs messages so inbox providers can verify they were not changed in transit | DNS provider |
| DMARC | Tells receivers how to evaluate mail that fails SPF or DKIM alignment | DNS provider |
| MAIL FROM | Aligns bounce handling with your sending domain | DNS provider |

In Migma:

<Steps>
  <Step title="Add a sending domain">
    Go to **Sending Domains** and add the domain or subdomain you want to send from.
  </Step>

  <Step title="Copy DNS records exactly">
    Add each record at your DNS provider. If you use Cloudflare, keep email authentication records **DNS only**.
  </Step>

  <Step title="Verify the records">
    Return to Migma and click **Check DNS** until the domain is verified.
  </Step>
</Steps>

Use [Add a Sending Domain](/sending-domains/add-domain) for the full setup flow. If a record does not verify, see [Verification Issues](/sending-domains/verification-issues).

***

## Keep Complaint Rate Low

User-reported spam is one of the clearest negative signals. [Google's sender guidelines](https://support.google.com/mail/answer/81126?hl=en) recommend keeping user-reported spam below 0.1% and preventing it from reaching 0.3% or higher. Migma's own domain health thresholds are stricter for managed domains because shared infrastructure needs tighter controls.

To reduce complaints:

* Send only to contacts with clear consent.
* Set expectations at signup about content and frequency.
* Use a recognizable sender name and a monitored reply address.
* Make the subject line match the email body.
* Avoid sending too often to inactive contacts.
* Make unsubscribe easy before people reach for the spam button.

Track domain status in [Domain Health](/sending-domains/domain-health) and campaign results in [Track Results](/campaigns/track-results).

***

## Make Unsubscribe Easy

Marketing and promotional email should include a visible unsubscribe or preference link in the message body. Large senders also need one-click unsubscribe headers for [Gmail](https://support.google.com/mail/answer/81126?hl=en) and [Yahoo](https://senders.yahooinc.com/best-practices/) inbox requirements.

Good unsubscribe behavior:

* Keep the unsubscribe or preference link visible in the footer.
* Do not require login to opt out.
* Honor opt-outs quickly. Migma suppression flows are designed to apply immediately to marketing sends.
* Offer topic or frequency choices when that helps subscribers stay on the right list.
* Never send marketing campaigns to suppressed contacts.

Related: [Preference Center](/audience/preference-center), [Suppression List](/sending-domains/suppression-list), [CAN-SPAM Checklist](/compliance/can-spam-checklist).

***

## Warm New Domains Gradually

New domains have little or no reputation. Sending a large campaign immediately can look suspicious, even when the audience opted in.

Use warming when:

* The domain or subdomain is new.
* You are moving from one email service provider to another.
* You have not sent consistent volume recently.
* You plan to increase volume significantly.

During warming:

* Start with engaged subscribers first.
* Send consistently within the daily limit.
* Pause broad campaigns if bounces or complaints rise.
* Avoid sudden jumps in volume or frequency.

See [Domain Warming](/sending-domains/domain-warming) for Migma's configurable warming plan and safety thresholds.

***

## Keep the List Clean

List quality has more impact than small copy tricks. Bounces, disposable addresses, role inboxes, spam traps, and long-inactive contacts all weaken reputation.

Use Migma to:

* Validate new contacts during import.
* Re-validate stale subscribed contacts.
* Exclude risky addresses from sends.
* Review skipped recipients after each campaign.
* Keep bounces, complaints, unsubscribes, and manual blocks suppressed.

For high-stakes campaigns, build a segment from recently engaged, valid contacts first. Then expand carefully after you confirm healthy delivery, bounce, complaint, open, and click signals.

Related: [Deliverability & Validation](/audience/deliverability), [Skipped Recipients](/campaigns/skipped-recipients), [Suppression List](/sending-domains/suppression-list).

***

## Send Relevant, Readable Email

Content still matters, but modern filtering is not about one magic word. Inboxes evaluate whether the message looks legitimate, matches recipient expectations, renders correctly, and gets healthy engagement.

Before sending, review:

* **Subject line**: truthful, specific, and aligned with the email body.
* **Sender identity**: recognizable brand or person, not a misleading alias.
* **Layout**: readable on mobile, clear hierarchy, no image-only email.
* **Links**: relevant destinations, no broken URLs, no unnecessary redirect chains.
* **Images**: compressed, useful alt text, and enough live text if images are blocked.
* **Accessibility**: readable contrast, descriptive link text, and scannable structure.
* **Dark mode**: text, logos, buttons, and backgrounds stay legible.

<Tip>
  Use a simple test: if a recipient opened this email without images, would they still understand who sent it, why they got it, and what to do next?
</Tip>

For rendering details, see [Email Client Compatibility](/email-editor/client-compatibility).

***

## Run Preflight Before Important Sends

Preflight checks the email Migma will actually send or export. Use it before production campaigns, especially after editing copy, links, images, or layout.

<Steps>
  <Step title="Open the email">
    Open the email draft or conversation you plan to send.
  </Step>

  <Step title="Run Email Preflight">
    Click **Compatibility Check** in the editor toolbar.
  </Step>

  <Step title="Review red and yellow items">
    Check rendering previews, CSS compatibility, links, spelling, compliance basics, and deliverability score.
  </Step>

  <Step title="Fix and re-run">
    Use **Fix with AI** where helpful, then run Preflight again before sending or exporting.
  </Step>
</Steps>

Preflight does not replace good list quality or domain reputation. It helps catch issues in the email itself before subscribers see them.

***

## Monitor After Sending

Deliverability work continues after send. Watch each campaign and domain over time so small issues do not become reputation problems.

| Signal | What to watch | Where |
| - | - | - |
| Bounce rate | Invalid, stale, or unreachable addresses | [Domain Health](/sending-domains/domain-health) |
| Complaint rate | People marking mail as spam | [Domain Health](/sending-domains/domain-health) |
| Skipped recipients | Suppressed, invalid, risky, or unsubscribed contacts held back | [Skipped Recipients](/campaigns/skipped-recipients) |
| Opens and clicks | Whether recipients are engaging | [Track Results](/campaigns/track-results) |
| Unsubscribes | Frequency, targeting, or expectation mismatch | [Track Results](/campaigns/track-results) |

If performance drops, narrow the next send to recent engagers, clean or re-validate the audience, review signup expectations, and check domain health before increasing volume again.

***

## Pre-Send Checklist

Before an important campaign:

* [ ] Audience has clear permission for this email.
* [ ] Suppressed, bounced, complained, and unsubscribed contacts are excluded.
* [ ] Sending domain is verified with SPF, DKIM, DMARC, and MAIL FROM.
* [ ] New domain is warming or already has steady sending history.
* [ ] Subject line matches the message.
* [ ] From name and reply-to are recognizable and monitored.
* [ ] Unsubscribe or preference link is visible and working.
* [ ] Email has enough live text if images are blocked.
* [ ] Mobile and dark mode previews are readable.
* [ ] Links work and use relevant destinations.
* [ ] Email Preflight has been run after final edits.
* [ ] Test email has been reviewed in a real inbox.

***

## Related Pages

<CardGroup>
  <Card title="Sending Rules" icon="envelope-circle-check" href="/get-started/what-you-can-send">
    Permission-based sending rules for Migma.
  </Card>

  <Card title="Add a Sending Domain" icon="globe" href="/sending-domains/add-domain">
    Set up and verify DNS records.
  </Card>

  <Card title="Deliverability & Validation" icon="shield-check" href="/audience/deliverability">
    Validate contacts and exclude risky addresses.
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Review rendering, links, content, compliance basics, and deliverability risk.
  </Card>

  <Card title="Domain Health" icon="heart-pulse" href="/sending-domains/domain-health">
    Monitor bounce and complaint rates.
  </Card>

  <Card title="CAN-SPAM Checklist" icon="gavel" href="/compliance/can-spam-checklist">
    Review U.S. commercial email requirements.
  </Card>
</CardGroup>


# Global Deliverability
Source: https://docs.migma.ai/advanced-features/global-deliverability

See your email from the mailbox side: cross-provider campaign analytics, pre-send inbox placement testing, and blocklist reputation monitoring.

Standard deliverability metrics tell you what left your sending domain. Global Deliverability tells you what actually happened at the inbox. It samples how real mailboxes around the world receive your mail, so you can see inbox placement, engagement, and reputation the way subscribers experience them.

It covers every campaign you send from your monitored domains, whether the mail goes out through Migma or through another provider.

<Info>
  Global Deliverability is an optional add-on available on any paid plan. [Contact us](mailto:sales@migma.ai?subject=Global%20Deliverability) to turn it on for your account.
</Info>

## What you get

<CardGroup>
  <Card title="Campaign analytics" icon="chart-mixed">
    Per-campaign inbox placement and engagement, sampled across major mailbox providers.
  </Card>

  <Card title="Inbox placement testing" icon="inbox-arrow-down">
    Send to seed accounts before your real send to catch placement and auth issues early.
  </Card>

  <Card title="Reputation monitoring" icon="shield-check">
    Watch your domains and IPs against the major blocklists, with alerts when anything is listed.
  </Card>
</CardGroup>

***

## Campaign analytics

Cross-provider insight into how each campaign lands, based on a representative sample of the mail sent from your monitored domains. Because the sample is measured at the mailbox, you get these signals even for campaigns that leave through a non-Migma provider.

* Campaign list with subject lines, sender, and projected volume.
* Inbox placement broken down by mailbox provider.
* Engagement signals per provider, such as read, open, and delete rates.

Use it to see which campaigns actually reach the inbox and where to tune the ones that do not.

***

## Inbox placement testing

Validate a campaign before you press send. Global Deliverability delivers your email to seed accounts across major mailbox providers and reports where it lands, so placement and authentication problems surface before real subscribers ever see them.

* Results across Gmail, Outlook, Yahoo, Apple Mail, and more.
* Overall and per-provider inbox vs. spam placement.
* SPF, DKIM, and DMARC validation for the tested send.

Run a test on important campaigns, fix anything flagged, then send with confidence.

***

## Reputation monitoring

Continuous monitoring of your sending domains and dedicated IPs against the industry's major blocklist operators, with frequent checks and proactive alerts when a resource gets listed.

* Domain and IP monitoring across Spamhaus, Barracuda, Invaluement, LashBack, and PSBL.
* Clear view of where a resource is listed and why.
* Direct links to the operator's delisting workflow so you can act fast.

Catching a listing early keeps a single bad send from turning into a lasting reputation problem.

***

## How to turn it on

Global Deliverability is provisioned by our team so we can match the monitored domains and IPs to your setup.

<Steps>
  <Step title="Contact us">
    Email [sales@migma.ai](mailto:sales@migma.ai?subject=Global%20Deliverability) and tell us which domains you send from.
  </Step>

  <Step title="We provision monitoring">
    We connect your domains and IPs and start collecting mailbox-perspective data.
  </Step>

  <Step title="Test and monitor">
    Run inbox placement tests before big sends and watch reputation and campaign results over time.
  </Step>
</Steps>

<Note>
  Global Deliverability adds visibility on top of the deliverability work already built into every plan. It does not replace good permission, domain authentication, or list hygiene. See [Email Deliverability Best Practices](/advanced-features/email-deliverability-best-practices).
</Note>

## Related Pages

<CardGroup>
  <Card title="Email Deliverability Best Practices" icon="inbox-arrow-down" href="/advanced-features/email-deliverability-best-practices">
    The operating checklist for reaching the inbox on every plan.
  </Card>

  <Card title="Domain Health" icon="heart-pulse" href="/sending-domains/domain-health">
    Monitor bounce and complaint rates for your sending domains.
  </Card>

  <Card title="Plans & Billing" icon="credit-card" href="/get-started/billing-and-plans">
    Compare plans and see how add-ons fit in.
  </Card>

  <Card title="Deliverability & Validation" icon="shield-check" href="/audience/deliverability">
    Validate contacts and exclude risky addresses before you send.
  </Card>
</CardGroup>


# Migma Agent Authentication Protocol
Source: https://docs.migma.ai/agent-auth

Implement Migma agent authentication with discovery, OAuth authorization codes, claim-code approval, scoped API keys, token exchange, and revocation.

<Note>
  Agent registration is in beta. For the user-facing overview of how approval works, see [Agent registration](/agent-registration). This page is the deeper protocol reference for developers building agents.
</Note>

Migma follows the [auth.md](https://workos.com/auth-md/docs) convention, so an agent can discover the flow and obtain its own scoped API key without a human copying a secret. MCP clients that can complete a browser redirect/callback should use the OAuth authorization-code flow. Direct clients that cannot complete that callback but can call the API, poll, and securely store a credential can use claim-code.

Base URL: `https://api.migma.ai`

The skill file an agent reads is served at `https://api.migma.ai/auth.md`.

## Discovery

Agents discover the endpoints and supported scopes from the well-known metadata. The `agent_auth` block in the authorization-server document lists `skill`, `register_uri` (same URL as `identity_endpoint`), `claim_uri` (same URL as `claim_endpoint`), and the `service_auth` method.

```text theme={null}
GET https://api.migma.ai/.well-known/oauth-authorization-server
GET https://api.migma.ai/.well-known/oauth-protected-resource
GET https://api.migma.ai/.well-known/oauth-protected-resource/mcp
```

The authorization-server document includes `scopes_supported`, `authorization_endpoint`, `registration_endpoint`, `token_endpoint`, `grant_types_supported`, PKCE support, and the `agent_auth` map (`skill`, `register_uri`, `identity_endpoint`, `claim_uri`, `claim_endpoint`, `service_auth`).

An agent that hits a protected API without a valid key receives `401` with a `WWW-Authenticate` challenge that points back to the protected-resource metadata, so it can find this flow:

```http theme={null}
WWW-Authenticate: Bearer resource_metadata="https://api.migma.ai/.well-known/oauth-protected-resource"
```

The MCP endpoint returns the same challenge pointing at its own resource metadata (`/.well-known/oauth-protected-resource/mcp`).

## Endpoints

| Method | Path | Auth | Rate limit | Purpose |
| - | - | - | - | - |
| `GET` | `/auth.md` | None | — | The agent skill file |
| `GET` | `/.well-known/oauth-authorization-server` | None | — | Authorization-server metadata (scopes, endpoints) |
| `GET` | `/.well-known/oauth-protected-resource` | None | — | Protected-resource metadata for the API |
| `GET` | `/.well-known/oauth-protected-resource/mcp` | None | — | Protected-resource metadata for the MCP server |
| `GET` | `/oauth2/authorize` | None | 30 / 5 min per IP | Start the OAuth authorization-code flow |
| `POST` | `/oauth2/register` | None | 10 / hour per IP | Optional dynamic client registration; supplies the name shown on the approval page |
| `POST` | `/agent/identity` | None | 60 / hour per IP | Step 1 — register intent, get a claim token and user code |
| `POST` | `/agent/identity/claim` | None | 20 / hour per IP | Step 4 — refresh an expired user code |
| `POST` | `/agent/identity/signup` | None | 10 / hour per IP | First-party clients only — create an account in-product |
| `POST` | `/oauth2/token` | None | 120 / 5 min per IP | Exchange an authorization code or poll a claim token |

The claim page endpoints (`/agent/identity/claim/lookup` and `/agent/identity/claim/complete`) are used by the Migma web UI when the user enters their code. Agents do not call them.

## First-party clients

A host-app extension published by Migma — today the Figma plugin — registers with `client_id` instead of `login_hint`, because it runs inside another product and cannot know the user's Migma account until they approve. The server, not the client, then decides the display name, the key name and the scopes, so a first-party client cannot widen its own grant:

```bash theme={null}
curl -X POST https://api.migma.ai/agent/identity \
  -H "Content-Type: application/json" \
  -d '{ "type": "service_auth", "client_id": "figma-plugin" }'
```

Everything else is the claim-code flow above.

### In-product sign-up

Those clients meet people who have no Migma account at all, and sending them to a registration form in another window loses most of them. `POST /agent/identity/signup` creates the account where they already are:

```bash theme={null}
curl -X POST https://api.migma.ai/agent/identity/signup \
  -H "Content-Type: application/json" \
  -d '{
    "claim_token": "<from /agent/identity>",
    "email": "designer@studio.com",
    "first_name": "Alex",
    "last_name": "Rivera",
    "website": "studio.com",
    "marketing_consent": false
  }'
```

* `claim_token` — required. Must belong to a pending, unexpired registration made by a first-party `client_id`; anything else is rejected.
* `email` — required. A conflict with an existing account answers `409 account_exists`.
* `first_name` — required. `last_name` and `website` are optional; `website` seeds the brand import and is normalised to a hostname.
* No password is accepted. The account is created passwordless and the person receives a link to set one, which also proves they own the address.

```json theme={null}
{ "status": "claimed", "account": { "email": "designer@studio.com", "first_name": "Alex" } }
```

The response deliberately carries no credential. Signing up claims the registration; the client then collects the key from `POST /oauth2/token` exactly as it would after a browser approval, so a key is minted in one place regardless of how the account came to exist.

This endpoint is not open to third-party agents, and it can be switched off server-side with `AGENT_AUTH_SIGNUP_ENABLED=false` without affecting sign-in for existing accounts.

## Authorization-code flow

Use this OAuth path for MCP clients that can open a browser approval flow.

<Steps>
  <Step title="Discover Migma auth metadata">
    Read `https://api.migma.ai/.well-known/oauth-authorization-server` to find the registration, authorization, token, and scope metadata.
  </Step>

  <Step title="Register the client">
    Register with a client name and redirect URI. Migma supports public clients with `authorization_code`, `code`, and `token_endpoint_auth_method: none`. Redirect URIs must use HTTPS, except localhost and 127.0.0.1 may use HTTP for local clients.
  </Step>

  <Step title="Start authorization with PKCE">
    Send the user through the authorization endpoint with `response_type=code`, the registered `client_id`, `redirect_uri`, requested `scope`, and PKCE `S256`. PKCE is required.
  </Step>

  <Step title="User approves on Migma">
    Migma shows the consent page at `migma.ai/connect/authorize`. The user signs in, reviews the client name, return host, and requested scopes, then approves or denies access. Migma marks `email:send` and `campaign:write` as delivery access.
  </Step>

  <Step title="Exchange the code">
    Exchange the code at the token endpoint with the same `client_id`, `redirect_uri`, and PKCE verifier. The response contains a scoped Migma API key in `access_token`.
  </Step>
</Steps>

Success body:

```json theme={null}
{
  "access_token": "sk_live_…",
  "token_type": "bearer",
  "scope": "email:read email:write campaign:read"
}
```

The key works anywhere a Migma API key works, including the hosted [MCP server](/mcp-server). It appears in **Settings → Developers → API Keys** and can be revoked there. No refresh token is issued.

## Claim-code fallback

Use this path when the agent cannot complete a browser OAuth redirect/callback but can call the API, poll, and securely store the once-only credential. Claim-code does not repair a broken hosted connector.

### Step 1 — Register intent

```bash theme={null}
curl -X POST https://api.migma.ai/agent/identity \
  -H "Content-Type: application/json" \
  -d '{
    "type": "service_auth",
    "agent_name": "Claude"
  }'
```

* `type` — required, must be `service_auth`. Identity-assertion and anonymous registration are not supported yet.
* `login_hint` — optional. The email of the user the agent acts for, shown on the approval page. It is display only; identity binds to whoever signs in and approves.
* `agent_name` — optional. Shown to the user at approval. Use your product name.
* `scope` — optional, space-delimited. Omit it for the full permission set; the approval page is the gate. Pass it only to narrow access.

Response:

```json theme={null}
{
  "claim_token": "<JWT, keep private>",
  "claim": {
    "user_code": "XXXX-XXXX",
    "verification_uri": "https://migma.ai/claim",
    "verification_uri_complete": "https://migma.ai/claim?code=XXXX-XXXX",
    "expires_in": 600,
    "interval": 5
  }
}
```

### Step 2 — Send the user to approve

Surface `verification_uri_complete` (or `verification_uri` plus `user_code`) to the user. They sign in to Migma, review the agent name and requested scopes, and confirm the code.

### Step 3 — Poll for the key

Poll the token endpoint every `interval` seconds (default 5):

```bash theme={null}
curl -X POST https://api.migma.ai/oauth2/token \
  -H "Content-Type: application/json" \
  -d '{
    "grant_type": "urn:workos:agent-auth:grant-type:claim",
    "claim_token": "<from step 1>"
  }'
```

Responses:

| Status | `error` | What to do |
| - | - | - |
| `400` | `authorization_pending` | The user has not confirmed yet. Keep polling. |
| `400` | `expired_token` | The user code expired. Refresh it (Step 4), surface the new code, keep polling. |
| `400` | `invalid_grant` | The claim is no longer usable. Start over at Step 1. |
| `200` | — | Success. The key is in `access_token`. |

Success body:

```json theme={null}
{
  "access_token": "sk_live_…",
  "token_type": "bearer",
  "scope": "email:read email:write campaign:read",
  "key_name": "Agent: Claude"
}
```

<Warning>
  The `access_token` is a Migma platform API key and is returned **exactly once**. Keep it and `claim_token` out of chat, logs, shell history, and shared files. If the client cannot do that, stop before registration. Further polls return `invalid_grant`.
</Warning>

### Step 4 — Refresh an expired user code

Only when polling returned `expired_token`:

```bash theme={null}
curl -X POST https://api.migma.ai/agent/identity/claim \
  -H "Content-Type: application/json" \
  -d '{ "claim_token": "<from step 1>" }'
```

Returns a fresh `claim` object with a new `user_code`. The whole registration expires one hour after Step 1; after that, start over.

### Code lifecycle

* The `user_code` expires after `expires_in` seconds (600 by default).
* Refresh an expired code with `POST /agent/identity/claim` using the same `claim_token`.
* The whole registration expires one hour after Step 1.
* The `access_token` is issued exactly once; re-polling after issuance returns `invalid_grant`.

### Poll loop example

```javascript theme={null}
async function registerAgent(loginHint) {
  const intent = await fetch('https://api.migma.ai/agent/identity', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      type: 'service_auth',
      login_hint: loginHint,
      agent_name: 'Claude'
    })
  }).then((r) => r.json());

  let { claim_token, claim } = intent;
  console.log('Approve at:', claim.verification_uri_complete);

  while (true) {
    await new Promise((r) => setTimeout(r, claim.interval * 1000));

    const res = await fetch('https://api.migma.ai/oauth2/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        grant_type: 'urn:workos:agent-auth:grant-type:claim',
        claim_token
      })
    });
    const body = await res.json();

    if (res.ok) return body.access_token; // sk_live_…

    if (body.error === 'authorization_pending') continue;

    if (body.error === 'expired_token') {
      const refreshed = await fetch('https://api.migma.ai/agent/identity/claim', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ claim_token })
      }).then((r) => r.json());
      claim = refreshed.claim;
      claim_token = refreshed.claim_token;
      console.log('New code:', claim.verification_uri_complete);
      continue;
    }

    // invalid_grant or anything else — start over
    throw new Error(`Registration failed: ${body.error}`);
  }
}
```

## Scopes

Scopes are space-delimited in the `scope` field of Step 1. Omit the field for the full permission set — the approval page lists every permission and marks send as destructive. Pass an explicit list to narrow access. The available scopes are published in `scopes_supported` in the discovery document:

| Scope | Grants |
| - | - |
| `audience:read` | View subscribers, tags, and segments |
| `audience:write` | Add and update subscribers, manage tags, create segments |
| `email:read` | View emails and sending history |
| `email:write` | Create and edit generated emails |
| `email:send` | Send test and live emails |
| `email:validate` | Run compatibility, link, and deliverability checks |
| `email:preview` | Generate device and client previews |
| `domain:read` | View sending domains, verification and purchase status, and custom DNS on domains bought in Migma |
| `domain:write` | Add, verify, update, and remove sending domains; buy a domain (Stripe checkout the account owner opens); manage custom DNS on domains bought in Migma |
| `campaign:read` | View campaigns and their stats and logs |
| `campaign:write` | Create, send, schedule, and manage campaigns |
| `webhook:read` | List and view webhooks |
| `webhook:write` | Create, update, and delete webhooks |
| `project:write` | Import projects and manage project resources |
| `billing:read` | View plan and credits |
| `billing:write` | Create billing links (Stripe checkout and portal) that the user opens and approves themself |

<Warning>
  `email:send` allows test and direct email. `campaign:write` allows campaign creation, send, and schedule. Even with a full-permission credential, agents confirm sends with the user in the conversation.
</Warning>

Omitted `scope` includes both billing scopes on every path.

## Using the credential

The `access_token` is an ordinary Migma API key. Send it as a bearer token and discover a project to work in:

```bash theme={null}
# 1. List projects to get a projectId
curl https://api.migma.ai/v1/projects?limit=1 \
  -H "Authorization: Bearer sk_live_…"

# 2. Use that projectId on project-scoped requests
curl "https://api.migma.ai/v1/campaigns?projectId=PROJECT_ID" \
  -H "Authorization: Bearer sk_live_…"
```

The key is account-scoped, so pass `projectId` per request; a resource in a project you did not name returns `404`. The key works everywhere a Migma key works: the [REST API](/api-reference/introduction), the [SDK](/sdk), the [CLI](/cli), and [MCP](/mcp-server), typically by setting `MIGMA_API_KEY`.

## Revocation

Agent keys appear in the Migma dashboard under **Settings → Developers → API Keys** alongside your own keys. The user can revoke one at any time. A revoked key fails with `401`; the agent should re-register to obtain a new one.


# Agent Registration
Source: https://docs.migma.ai/agent-registration

Approve Claude, Cursor, OpenClaw, and other agents through Migma OAuth or a one-time claim code, giving each client its own scoped API key.

<Note>
  Agent registration is in beta.
</Note>

AI agents and MCP clients like Claude, Cursor, and OpenClaw can register themselves with your Migma account.

Start with the first path that works:

1. Hosted MCP: add `https://migma.ai/mcp` and approve in the browser.
2. CLI: run `migma login`.
3. Direct client without a working OAuth callback: fetch `https://api.migma.ai/auth.md` and approve the claim code (this page).
4. CI: set `MIGMA_API_KEY`. Do not send agents to Settings to copy a key.

Clients with a working browser callback can send you through Migma's OAuth consent page. Direct agents without that callback can show you a short claim code. In both cases, the agent receives its own scoped API key without you copying or pasting a secret.

## Why use it

<CardGroup>
  <Card title="No key handling" icon="key">
    The agent receives its own key directly. The secret never passes through chat, clipboards, or config files you manage by hand.
  </Card>

  <Card title="You approve every agent" icon="user-check">
    Before any access is granted you see the agent's name and exactly which permissions it asked for, then approve it in Migma.
  </Card>

  <Card title="Scoped access" icon="shield-check">
    The key carries only the permissions the agent requested, such as read-only access or sending. Nothing more.
  </Card>

  <Card title="Revoke anytime" icon="ban">
    Agent keys appear in **Settings → Developers → API Keys** next to your own keys. Delete one and the agent loses access immediately.
  </Card>
</CardGroup>

This works with OAuth-capable MCP clients and with direct agents that can make HTTPS requests, poll, keep claim tokens private, and securely store a returned credential. Reading a web page alone is not enough. Migma follows the [auth.md](https://workos.com/auth-md/docs) convention so capable agents can discover the flow.

## How it works

### OAuth connector approval

<Steps>
  <Step title="Your client asks to connect">
    Add Migma as a connector or hosted MCP server. The client discovers Migma's sign-in and consent flow automatically.
  </Step>

  <Step title="You review and approve">
    Migma opens `migma.ai/connect/authorize`. You see the app name, return host, and requested permissions before approving. Sending access is highlighted as `email:send`.
  </Step>

  <Step title="The client receives its key">
    Once you approve, Migma gives the client a scoped API key automatically. You do not copy or paste a key.
  </Step>
</Steps>

### Claim-code fallback

<Steps>
  <Step title="Your agent asks to connect">
    While working on your behalf, the agent registers with Migma and shows you a short code together with a link to `migma.ai/claim`. The agent does not approve its own request.
  </Step>

  <Step title="You review and approve">
    Open the link, sign in (or create a free account), and enter the code. Migma shows the agent's name and the permissions it requested before you confirm.
  </Step>

  <Step title="The agent picks up its key">
    Once you approve, the agent automatically receives a scoped API key and continues working. The key is shown to the agent exactly once.
  </Step>
</Steps>

## For agents

Everything an agent needs is published at:

```text theme={null}
https://api.migma.ai/auth.md
```

Machine-readable metadata is at `https://api.migma.ai/.well-known/oauth-authorization-server`. OAuth-capable clients should use the authorization-code flow with PKCE. Direct agents that cannot complete the OAuth redirect/callback can use claim-code when they can securely store the returned credential. Claim-code does not repair a broken hosted connector. `login_hint` is optional — identity binds to whoever signs in and approves in the browser. In short:

```bash theme={null}
# 1. Register intent for the user you act for
curl -X POST https://api.migma.ai/agent/identity \
  -H "Content-Type: application/json" \
  -d '{"type":"service_auth","agent_name":"Claude"}'

# 2. Surface claim.user_code and claim.verification_uri_complete to the user

# 3. Poll until approved
curl -X POST https://api.migma.ai/oauth2/token \
  -H "Content-Type: application/json" \
  -d '{"grant_type":"urn:workos:agent-auth:grant-type:claim","claim_token":"<from step 1>"}'
```

The returned `access_token` is a standard Migma API key. Use it everywhere a key works: the [REST API](/api-reference/introduction), the [SDK](/sdk), the [CLI](/cli), and [MCP](/mcp-server), typically by setting `MIGMA_API_KEY`.

For the full protocol — discovery endpoints, scopes, code lifecycle, poll-loop error codes, and a complete poll-loop example — see the [agent-auth developer reference](/agent-auth).

## Security

* Claim-code approval requires a signed-in Migma user entering a short-lived code. The email an agent mentions is display only and grants nothing by itself.
* OAuth consent requires a signed-in Migma user approving the client at `migma.ai/connect/authorize`.
* Requested scopes are capped to the standard [API permissions](/authentication) and shown to you before approval.
* `email:send` allows test and direct email. `campaign:write` allows campaign creation, send, and schedule. A credential with `campaign:write` is not no-send.
* Codes expire after ten minutes and a registration expires after one hour.
* The key is delivered to the agent exactly once and is never shown again.
* Keep claim tokens and the returned key out of chat, logs, shell history, and shared remote-computer files.
* Revoke any agent key in **Settings → Developers → API Keys**.
* IT and security reviewers: [MCP for IT admins](/security/mcp).


# Migma Agent Setup: Skills, CLI, and MCP
Source: https://docs.migma.ai/agent-setup

Set up Migma in Claude Code, Codex, Cursor, or another AI coding agent with one prompt that installs the skills, CLI, and MCP server, then signs you in.

Paste this into Claude Code, Codex, Cursor, Grok Bot, or another AI agent:

```text theme={null}
Fetch and execute the appropriate instructions to set me up for Migma from https://docs.migma.ai/agent-setup.md
```

The agent fetches this page as markdown and runs the setup itself. Everything below this line is written for the agent.

<Info>
  Grok Bot desktop reads [its dedicated setup page](/grok), adds Migma Remote MCP, and uses connected Migma tools for routine work.
</Info>

***

These are official instructions from Migma to set up an AI development environment for creating, validating, and sending email with Migma. All commands are validated by Migma and ready to use.

Complete all setup commands directly. Involve the user for browser sign-in and access approval.

* Install Migma skills and the Migma CLI
* Register the Migma MCP server
* Sign the user in

For Grok Bot desktop, fetch `https://docs.migma.ai/grok.md`, follow that page, and ask before adding `https://migma.ai/mcp`.

***

## Install Migma skills and CLI

Use the correct section for your agent below.

### Claude Code

Run these two commands to install the Migma plugin, which bundles the `setup`, `migma`, and `migma-public-api` skills. Do not use `npx skills` here; the plugin commands handle everything.

```bash theme={null}
claude plugin marketplace add MigmaAI/migma-skills
claude plugin install migma@migma-plugins
```

Then instruct the user to run `/reload-plugins` inside Claude Code to activate the plugin.

### Codex

```bash theme={null}
codex plugin marketplace add MigmaAI/migma-skills
codex plugin add migma@migma-plugins
```

### All other agents

Install the CLI and all Migma skills together:

```bash theme={null}
curl -fsSL https://install.migma.ai/setup | sh
```

Or install only the skills:

```bash theme={null}
npx -y skills add MigmaAI/migma-skills -g
```

***

## Register the Migma MCP server

Migma Remote MCP is a single URL: `https://migma.ai/mcp` (Streamable HTTP). Use the default config location for your agent. OAuth opens the browser on first Migma tool use and handles credential exchange.

### Claude Code

```bash theme={null}
claude mcp add --scope user --transport http migma https://migma.ai/mcp
```

### Codex

```bash theme={null}
codex mcp add migma --url https://migma.ai/mcp
codex mcp login migma
```

### OpenCode — `~/.config/opencode/opencode.jsonc`

Add under `"mcp"`:

```json theme={null}
"migma": { "type": "remote", "url": "https://migma.ai/mcp", "enabled": true, "oauth": {} }
```

Then run:

```bash theme={null}
opencode mcp auth migma
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Add under `"mcpServers"` (note: `serverUrl`, not `url`):

```json theme={null}
"migma": { "serverUrl": "https://migma.ai/mcp" }
```

### Cursor, GitHub Copilot, and all other agents

Add to `.cursor/mcp.json` (Cursor), `.vscode/mcp.json` (Copilot), or your agent's MCP config file under `"mcpServers"`:

```json theme={null}
"migma": { "url": "https://migma.ai/mcp" }
```

If your client only supports command-based MCP servers, use Local MCP instead:

```json theme={null}
"migma": { "command": "npx", "args": ["-y", "@migma/mcp"] }
```

***

## Sign the user in

If you installed the CLI, run:

```bash theme={null}
migma login
```

This opens the browser so the user can approve access. Wait for them to finish. Do not send the user to Settings to copy an API key.

If a direct agent cannot complete the OAuth callback, it can follow `https://api.migma.ai/auth.md`: show the user the claim link, stop for human approval, poll for the credential, and keep it out of chat, logs, shell history, and shared files. CI and server automation can set `MIGMA_API_KEY`.

Remote MCP handles its own sign-in: the first Migma tool call opens the browser for OAuth approval.

Right after sign-in, call `migma_get_context`, read its `setup` block, and tell the user the one next step: brand kit, design references, audience, sending domain, or first email, whichever is missing first.

***

## Rules for working with Migma

* Prefer the installed `migma` skill and available MCP tools for the task. Call the capabilities tool directly when needed.
* Ask before creating emails, sending tests, sending live, or changing contacts and campaigns.
* Keep API keys and send calls server-side.
* Send API keys through the documented authorization header.

Once done, tell the user:

```text theme={null}
┌─ Migma Agent Setup Complete ─────────────────────────┐
│  ✓ Skills  <path>                                    │
│  ✓ CLI     migma (signed in)                         │
│  ✓ MCP     <path>                                    │
│                                                      │
│  ⚡ Restart your agent to load the Migma MCP server  │
└──────────────────────────────────────────────────────┘
```

***

## Resources

For setup guides and troubleshooting, refer to:

* Migma docs index: `https://docs.migma.ai/llms.txt`
* Wiring Migma into an app: `https://docs.migma.ai/setup`
* MCP server: `https://docs.migma.ai/mcp-server`
* Grok Bot: `https://docs.migma.ai/grok.md`
* CLI: `https://docs.migma.ai/cli`
* Skills repository: `https://github.com/MigmaAI/migma-skills`
* Agent auth: `https://api.migma.ai/auth.md`

These instructions are published at `https://docs.migma.ai/agent-setup.md` so you can re-verify their authenticity at any time.


# Hand Off Migma Setup to an AI Agent
Source: https://docs.migma.ai/agents/agent-handoff

Copy a Migma setup prompt into Claude Code, Codex, Cursor, or an app-builder agent so it can audit email triggers and wire reviewed backend sends.

Agent handoff copies the right Migma instructions for the agent you are already using. Use it when a coding agent needs to audit an app, create or reuse Migma emails, and wire backend sends safely.

## Handoff paths

| Surface | Use it for | What gets copied |
| - | - | - |
| **Create → Set up Migma with agent** | First-time app setup | `/setup` skill/plugin install paths, agent auth, sender/domain status, and backend wiring steps |
| **Publish or Send via API → Copy for AI** | Use one email in an app | selected `emailId`, sender/domain status, agent auth, and send instructions |
| **Canvas export → Copy for AI** | Wire selected canvas emails | selected email IDs, future-email preference, sender/domain status, and app wiring steps |

## First-time app setup

<Steps>
  <Step title="Open Create">
    In Migma, open **Create** and click **Set up Migma with agent** beside the composer send button.
  </Step>

  <Step title="Copy for AI">
    Migma checks sender and domain status, then copies a setup prompt for Claude Code, Codex, Cursor, or any skills-compatible agent.
  </Step>

  <Step title="Paste into your agent">
    Paste the prompt into the agent working inside your app repository. It tells the agent to use the official setup skill or plugin when available.
  </Step>

  <Step title="Approve access">
    The prompt tells the agent to use [agent registration](/agent-registration) first. You approve a short code, and the agent receives a scoped key. Use a fallback API key only when that flow is unavailable.
  </Step>

  <Step title="Review the report">
    The agent should report the stack found, email systems found, Migma brand used, email IDs created or reused, files changed, and dry-run result.
  </Step>
</Steps>

## What the `/setup` prompt asks for

* Audit transactional sends, templates, newsletters, lifecycle jobs, queues, webhooks, and existing provider config.
* Resolve the right Migma brand after credentials are ready.
* Reuse matching Migma emails before creating new ones.
* Create missing emails from code evidence: trigger files, recipients, variables, subject copy, CTAs, and timing.
* Store `emailId`, subject, sender, and trigger mapping in server-side config.
* Wire sends only through trusted backend paths.
* Add idempotency and one dry-run or smoke test before live sends.

## Existing email handoff

Use **Copy for AI** from Publish, Send via API, or canvas export when an email already exists in Migma. This path does not use the full setup skill by default. It gives the agent selected `emailId` values and instructions for wiring those emails into the app.

## Live agent status

External agents can show up in Migma while they work. On Create, Migma shows the agent activity pill, types the incoming prompt into the composer, and opens the generated chat when the agent-created conversation is ready.

## Related

<CardGroup>
  <Card title="/setup" icon="plug" href="/setup">
    Full setup skill and plugin guide.
  </Card>

  <Card title="Agent Registration" icon="key" href="/agent-registration">
    Scoped agent access without copy-pasting keys.
  </Card>

  <Card title="Skills" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/skill.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=16eaf6658a39a735ef9f2afd040eba19" href="/skills">
    Install Migma workflows into supported agents.
  </Card>

  <Card title="AI App Builders" icon="cube" href="/agents/app-builders">
    Lovable, Bolt, v0, Replit, and similar builders.
  </Card>
</CardGroup>


# Use Migma with Bolt
Source: https://docs.migma.ai/agents/app-builder-bolt

Use Migma with Bolt when an AI-built app needs transactional emails, campaign drafts, contacts, webhooks, or delivery logs.

Use Migma with Bolt when an AI-built app needs transactional emails, campaign drafts, contacts, webhooks, or delivery logs.

## Recommended setup

<Steps>
  <Step title="Start from Migma handoff">
    In Migma, open **Create**, click **Set up Migma with agent**, and paste the copied `/setup` prompt into Bolt's agent.
  </Step>

  <Step title="Approve agent access">
    Use [agent registration](/agent-registration) first. Add `MIGMA_API_KEY` as a Bolt backend secret only if the agent cannot complete registration.
  </Step>

  <Step title="Add a fallback secret">
    Store `MIGMA_API_KEY` in Bolt's backend environment. Do not expose it in browser code.
  </Step>

  <Step title="Create or choose emails">
    Prepare emails in Migma and save returned `emailId` values in backend config.
  </Step>

  <Step title="Wire backend sends">
    Send from server routes, jobs, or trusted functions only.
  </Step>
</Steps>

## Prompt

Use this only if you cannot copy the in-app handoff prompt.

```text theme={null}
Use Migma's /setup workflow for this Bolt app.
Use agent registration before asking me for an API key.
Find all current email triggers.
Create or reuse Migma emails for each trigger.
Store emailId values in backend config.
Add dry-run tests before any live send.
```

## Next

<CardGroup>
  <Card title="AI App Builders" icon="cube" href="/agents/app-builders">
    Builder checklist and surface choice.
  </Card>

  <Card title="Agent Handoff" icon="copy" href="/agents/agent-handoff">
    In-app setup prompt and Copy for AI flow.
  </Card>

  <Card title="Setup Workflow" icon="plug" href="/setup">
    Agent-guided app wiring.
  </Card>
</CardGroup>


# Use Migma with Lovable
Source: https://docs.migma.ai/agents/app-builder-lovable

Use Migma with Lovable when an AI-built app needs real email sending, campaign drafts, contacts, webhooks, or delivery logs.

Use Migma with Lovable when an AI-built app needs real email sending, campaign drafts, contacts, webhooks, or delivery logs.

## Recommended setup

<Steps>
  <Step title="Start from Migma handoff">
    In Migma, open **Create**, click **Set up Migma with agent**, and paste the copied `/setup` prompt into Lovable's agent.
  </Step>

  <Step title="Approve agent access">
    Use [agent registration](/agent-registration) first. Add `MIGMA_API_KEY` as a Lovable backend secret only if the agent cannot complete registration.
  </Step>

  <Step title="Add a fallback secret">
    Store `MIGMA_API_KEY` in Lovable's backend environment. Do not expose it in browser code.
  </Step>

  <Step title="Create or choose emails">
    Prepare emails in Migma and save returned `emailId` values in backend config.
  </Step>

  <Step title="Wire backend sends">
    Send from server routes, jobs, or trusted functions only.
  </Step>
</Steps>

## Prompt

Use this only if you cannot copy the in-app handoff prompt.

```text theme={null}
Use Migma's /setup workflow for this Lovable app.
Use agent registration before asking me for an API key.
Find signup, invite, billing, and notification email triggers.
Use existing Migma emailId values where available.
Wire sends only in backend code.
Add a dry-run path before live sending.
```

## Next

<CardGroup>
  <Card title="AI App Builders" icon="cube" href="/agents/app-builders">
    Builder checklist and surface choice.
  </Card>

  <Card title="Agent Handoff" icon="copy" href="/agents/agent-handoff">
    In-app setup prompt and Copy for AI flow.
  </Card>

  <Card title="API Quickstart" icon="code-bracket-square" href="/quickstart">
    Send your first API request.
  </Card>
</CardGroup>


# Use Migma with Replit
Source: https://docs.migma.ai/agents/app-builder-replit

Use Migma with Replit when an app or agent needs transactional emails, campaign drafts, contacts, webhooks, or delivery logs.

Use Migma with Replit when an app or agent needs transactional emails, campaign drafts, contacts, webhooks, or delivery logs.

## Recommended setup

<Steps>
  <Step title="Start from Migma handoff">
    In Migma, open **Create**, click **Set up Migma with agent**, and paste the copied `/setup` prompt into Replit Agent.
  </Step>

  <Step title="Approve agent access">
    Use [agent registration](/agent-registration) first. Add `MIGMA_API_KEY` to Replit Secrets only if the agent cannot complete registration.
  </Step>

  <Step title="Add a fallback secret">
    Store `MIGMA_API_KEY` in Replit Secrets.
  </Step>

  <Step title="Choose a surface">
    Use the SDK for Node.js apps, REST for any backend runtime, or CLI for terminal workflows.
  </Step>

  <Step title="Wire backend sends">
    Send from server code, jobs, or trusted functions only.
  </Step>
</Steps>

## Prompt

Use this only if you cannot copy the in-app handoff prompt.

```text theme={null}
Use Migma's /setup workflow for this Replit app.
Use agent registration before asking me for an API key.
Find email triggers and existing templates.
Create or reuse Migma emails.
Store emailId values in backend config.
Add a dry-run test before live sending.
```

## Next

<CardGroup>
  <Card title="Agent Handoff" icon="copy" href="/agents/agent-handoff">
    In-app setup prompt and Copy for AI flow.
  </Card>

  <Card title="CLI" icon="terminal" href="/cli">
    Use Migma from terminal workflows.
  </Card>

  <Card title="Webhooks" icon="arrow-path" href="/webhooks">
    Trigger app workflows from Migma events.
  </Card>
</CardGroup>


# Use Migma with v0
Source: https://docs.migma.ai/agents/app-builder-v0

Use Migma with v0 when generated app code needs production email sending, campaign drafts, contacts, webhooks, or delivery logs.

Use Migma with v0 when generated app code needs production email sending, campaign drafts, contacts, webhooks, or delivery logs.

## Recommended setup

<Steps>
  <Step title="Start from Migma handoff">
    In Migma, open **Create**, click **Set up Migma with agent**, and paste the copied `/setup` prompt into the coding agent editing your v0 app.
  </Step>

  <Step title="Approve agent access">
    Use [agent registration](/agent-registration) first. Add `MIGMA_API_KEY` to server environment variables only if the agent cannot complete registration.
  </Step>

  <Step title="Keep fallback key server-side">
    Store `MIGMA_API_KEY` in server environment variables. Do not put it in client components.
  </Step>

  <Step title="Use email IDs">
    Prepare emails in Migma and store `emailId` values in server config.
  </Step>

  <Step title="Send from backend routes">
    Wire sends through route handlers, server actions, or trusted jobs.
  </Step>
</Steps>

## Prompt

Use this only if you cannot copy the in-app handoff prompt.

```text theme={null}
Use Migma's /setup workflow for this v0 app.
Use agent registration before asking me for an API key.
Use server routes or server actions only.
Map every email trigger to a Migma emailId.
Add a dry-run test path before live sending.
```

## Next

<CardGroup>
  <Card title="Agent Handoff" icon="copy" href="/agents/agent-handoff">
    In-app setup prompt and Copy for AI flow.
  </Card>

  <Card title="API Quickstart" icon="code-bracket-square" href="/quickstart">
    Send your first API request.
  </Card>

  <Card title="SDK" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/npm.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=1839361b0494d7d3199cdaa3575846ac" href="/sdk">
    Use Migma from Node.js or TypeScript.
  </Card>
</CardGroup>


# Use Migma with AI App Builders
Source: https://docs.migma.ai/agents/app-builders

AI app builders can use Migma when an app needs real email creation, sending, campaign workflows, contacts, webhooks, or delivery logs.

AI app builders can use Migma when an app needs real email creation, sending, campaign workflows, contacts, webhooks, or delivery logs.

Use [agent registration](/agent-registration) first for agent access. If a fallback key is needed, create it from **Settings → Developers → API Keys**. Create webhooks from **Settings → Developers → Webhooks**.

Start with **Create → Set up Migma with agent** when the builder has a coding agent or repo-aware assistant. Migma copies the `/setup` handoff prompt so the agent audits the app, creates or reuses emails, and wires backend sends safely.

Use the surface your builder supports:

* **Agent handoff** for first-time app setup from Migma
* **REST API** for production app code
* **SDK** for TypeScript and Node.js apps
* **CLI** for terminal-capable builders
* **Setup workflow** when a coding agent can inspect and edit the repository
* **MCP** when the builder supports MCP tools

## Best path

<Steps>
  <Step title="Copy the setup handoff">
    In Migma, open **Create**, click **Set up Migma with agent**, then copy the prompt.
  </Step>

  <Step title="Paste into the builder agent">
    Use the agent that can inspect and edit the app repository.
  </Step>

  <Step title="Approve access">
    Let the agent use [agent registration](/agent-registration) first. Add a fallback API key only when needed.
  </Step>

  <Step title="Review the dry-run">
    Before live sends, confirm the agent mapped each trigger to the right `emailId` and added a smoke test.
  </Step>
</Steps>

## Builder guides

<CardGroup>
  <Card title="Lovable" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/lovable.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=20f45e55be5abfd91b95783e7afb197e" href="/agents/app-builder-lovable">
    Add Migma to Lovable backend sends.
  </Card>

  <Card title="Bolt" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/bolt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=9ac9f2cac4dd8d9ee15cf14a66419d6a" href="/agents/app-builder-bolt">
    Add Migma to Bolt app email triggers.
  </Card>

  <Card title="v0" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/v0.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=74822a0a928a8a979d846c29a9d3c418" href="/agents/app-builder-v0">
    Use Migma from server routes or server actions.
  </Card>

  <Card title="Replit" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/replit.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=152058a6cf2a2ce13566c147cca9eade" href="/agents/app-builder-replit">
    Use Migma from Replit apps, agents, and jobs.
  </Card>
</CardGroup>

## Builder checklist

<Steps>
  <Step title="Prefer the handoff prompt">
    Use **Set up Migma with agent** instead of manually writing a long integration prompt.
  </Step>

  <Step title="Keep secrets server-side">
    Store `MIGMA_API_KEY` in the builder's server-side environment or secret manager.
  </Step>

  <Step title="Create or choose a brand">
    Use a Migma brand/project so emails use the right logo, colors, sender, and audience context.
  </Step>

  <Step title="Prepare email IDs">
    Generate or select emails in Migma, then store returned `emailId` values in backend config.
  </Step>

  <Step title="Wire sends in backend code">
    Send only from server routes, jobs, or trusted functions. Do not send directly from browser code.
  </Step>

  <Step title="Add dry-run checks">
    Test that each app trigger selects the right `emailId` without sending duplicates.
  </Step>
</Steps>

## Suggested prompt

```text theme={null}
Use Migma's /setup workflow for this app.
Fetch https://docs.migma.ai/llms.txt first.
Use agent registration before asking me for an API key.
Audit email triggers, templates, providers, queues, webhooks, and jobs.
Create or reuse Migma emails, store emailId values server-side, and add a dry-run before live sends.
```

## When to use each surface

| Surface | Use it for |
| - | - |
| Agent handoff | Copy the right setup prompt from Migma into the builder agent |
| Setup workflow | App audit, mapping existing emails, backend send wiring |
| REST API | Production app integration |
| SDK | Node.js and TypeScript apps |
| CLI | Terminal workflows and agent scripts |
| MCP | Agent work inside MCP-capable builders |

## Next

<CardGroup>
  <Card title="Setup Workflow" icon="plug" href="/setup">
    Agent-guided app wiring.
  </Card>

  <Card title="Agent Handoff" icon="copy" href="/agents/agent-handoff">
    Copy setup and selected-email prompts from Migma.
  </Card>

  <Card title="API Quickstart" icon="code-bracket-square" href="/quickstart">
    Send your first API request.
  </Card>

  <Card title="SDK" icon="code-bracket" href="/sdk">
    Use Migma from Node.js or TypeScript.
  </Card>

  <Card title="Webhooks" icon="arrow-path" href="/webhooks">
    Trigger app workflows from Migma events.
  </Card>
</CardGroup>


# Connect Migma MCP to Antigravity
Source: https://docs.migma.ai/agents/mcp-antigravity

Use Migma MCP in Antigravity when an agent needs to prepare emails, review campaigns, manage contacts, or wire backend sends inside an Antigravity workspace.

Use Migma MCP in Antigravity when an agent needs to prepare emails, review campaigns, manage contacts, or wire backend sends inside an Antigravity workspace.

## Local MCP

Open Antigravity's MCP manager and add a custom server. If you edit raw config, use:

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "command": "npx",
      "args": ["-y", "@migma/mcp"],
      "env": {
        "MIGMA_API_KEY": "your_migma_api_key"
      }
    }
  }
}
```

Restart Antigravity or refresh MCP tools after saving.

## Remote MCP

Use Remote MCP if your Antigravity version supports HTTP MCP servers with custom headers:

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "url": "https://migma.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MIGMA_API_KEY}"
      }
    }
  }
}
```

## Verify

Ask Antigravity:

```text theme={null}
Show my Migma context and suggest what we should do first.
```

## Next

<CardGroup>
  <Card title="MCP Server" icon="server" href="/mcp-server">
    Remote and local MCP details.
  </Card>

  <Card title="Skills" icon="wrench-screwdriver" href="/skills">
    Install Migma skills when Antigravity supports skill folders.
  </Card>
</CardGroup>


# Connect Migma MCP to ChatGPT
Source: https://docs.migma.ai/agents/mcp-chatgpt

Connect Migma to ChatGPT through the public plugin or a managed custom connector, approve access in your browser, and verify the connection safely.

For screenshots and real email workflows, use the [ChatGPT tutorial](/tutorials/connect-migma-to-chatgpt).

## Public Migma plugin

1. Open **Plugins** from the ChatGPT sidebar or **Settings → Plugins**.
2. Search for **Migma** and open the listing.
3. Choose **Connect** when shown, or **Try now** if already installed.
4. Invoke Migma with `@Migma` or **+ → More → Migma**.
5. Finish browser approval when ChatGPT asks.

Availability depends on plan, region, role, supported surface, and workspace settings. A workspace admin may need to enable Migma.

## Managed custom connection

Workspaces that manage their own connector can add this remote address:

```text theme={null}
https://migma.ai/mcp
```

Use browser approval. Do not paste a Migma API key into ChatGPT.

## Verify without changing anything

```text theme={null}
@Migma Show my Migma context and suggest what we should do first.
```

## Revoke access

Disconnect Migma under **ChatGPT → Settings → Apps**. Then open **Migma → Settings → Developers → API Keys** and revoke the ChatGPT connection key when you want access invalidated immediately.

## Next

<CardGroup>
  <Card title="ChatGPT tutorial" icon="route" href="/tutorials/connect-migma-to-chatgpt">
    Follow the visual setup and create a safe first email series.
  </Card>

  <Card title="Security and permissions" icon="shield-check" href="/security/mcp">
    Review access, approval, and revocation.
  </Card>
</CardGroup>


# Connect Migma MCP to Claude
Source: https://docs.migma.ai/agents/mcp-claude

Connect Migma MCP to Claude Code, Claude Desktop, or Claude.ai with browser OAuth, then verify brand access and review the granted permissions.

Use Migma with Claude to design on-brand emails, import audiences, save brand facts, run campaigns, and read results. Browser OAuth connects it — no API key to paste.

Visual setup and marketing workflow: [Use Migma with Claude Code and Desktop](/tutorials/connect-migma-to-claude-code).

## Recommended: Claude.ai custom connector

Add Migma as a custom connector with one URL:

```text theme={null}
https://migma.ai/mcp
```

Claude opens Migma in your browser. Sign in, review the permissions, and approve — full access lets Claude design, import audiences, and send for you, and sends still get confirmed in the chat. Migma creates the connection key automatically.

IT and security reviewers: [MCP for IT admins](/security/mcp) covers what the connector can do, how OAuth works, and how to revoke access.

After connecting, start with real work such as listing brands or designing an email.

## Claude Code

Add Migma for your user account:

```bash theme={null}
claude mcp add --scope user --transport http migma https://migma.ai/mcp
```

Then open `/mcp`, choose Migma, and finish browser approval. Check the saved connection with:

```bash theme={null}
claude mcp get migma
```

## Claude Desktop and Claude.ai

Open **Customize → Connectors**, choose **Add custom connector**, then enter:

* **Name:** `Migma`
* **Remote MCP server URL:** `https://migma.ai/mcp`

Leave optional OAuth client fields empty. Each person signs in to their own Migma account through the browser.

## Verify without changing anything

```text theme={null}
Show my Migma context and suggest what we should do first.
```

## Local fallback

Use Local MCP only when a client cannot use the remote browser connection. See [Migma MCP server](/mcp-server) for the command-based setup.

## Revoke access

Disconnect Migma in Claude. Then open **Migma → Settings → Developers → API Keys** and revoke the Claude connection key when you want access invalidated immediately.

## Next

<CardGroup>
  <Card title="Claude tutorial" icon="route" href="/tutorials/connect-migma-to-claude-code">
    Follow visual setup, then design, prepare campaigns, and read results.
  </Card>

  <Card title="MCP Server" icon="server" href="/mcp-server">
    Remote and local MCP details.
  </Card>

  <Card title="MCP for IT admins" icon="shield-check" href="/security/mcp">
    Permissions, OAuth, and how to revoke the connector.
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    Review scopes and revoke connected keys.
  </Card>
</CardGroup>


# Connect Migma MCP to Codex CLI
Source: https://docs.migma.ai/agents/mcp-codex

Connect Migma MCP to Codex CLI, use the setup workflow to audit application email triggers, verify capabilities, and keep backend sends reviewable.

Use Migma MCP in Codex CLI when a coding agent needs to prepare or send email work while editing an app.

If your Codex version supports Remote MCP, add `https://migma.ai/mcp` and approve in the browser. See [MCP Server](/mcp-server). Otherwise run `migma login`, then use Local MCP.

## Local MCP

Add Migma to your Codex config after `migma login` (or set `MIGMA_API_KEY` for CI):

```toml theme={null}
[mcp_servers.migma]
command = "npx"
args = ["-y", "@migma/mcp"]

[mcp_servers.migma.env]
MIGMA_API_KEY = "your_migma_api_key"
```

Restart active Codex sessions after changing config.

## Use with setup workflow

For app integration work, install the Migma plugin or setup skill too:

```bash theme={null}
codex plugin marketplace add MigmaAI/migma-skills
codex plugin add migma@migma-plugins
```

Then ask Codex to run the setup workflow:

```text theme={null}
Use Migma setup. Audit this app for email triggers, create missing Migma emails, and wire backend sends only after review.
```

## Verify

Ask Codex:

```text theme={null}
Show my Migma context and suggest what we should do first.
```

## Next

<CardGroup>
  <Card title="Setup Workflow" icon="plug" href="/setup">
    Add Migma to an existing app safely.
  </Card>

  <Card title="Skills" icon="wrench-screwdriver" href="/skills">
    Install Migma skills for Codex.
  </Card>
</CardGroup>


# Connect Migma MCP to GitHub Copilot
Source: https://docs.migma.ai/agents/mcp-copilot

Use Migma MCP with GitHub Copilot when Copilot Agent mode needs to prepare emails, inspect contacts, create campaigns, or wire email sends while editing code.

Use Migma MCP with GitHub Copilot when Copilot Agent mode needs to prepare emails, inspect contacts, create campaigns, or wire email sends while editing code.

## VS Code

Add Migma to `mcp.json` in your user profile or workspace:

```json theme={null}
{
  "inputs": [
    {
      "type": "promptString",
      "id": "migma-api-key",
      "description": "Migma API key",
      "password": true
    }
  ],
  "servers": {
    "migma": {
      "type": "http",
      "url": "https://migma.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${input:migma-api-key}"
      }
    }
  }
}
```

Reload MCP tools from VS Code, then use Copilot Agent mode.

## Copilot CLI

If your Copilot CLI setup reads `mcpServers`, use Local MCP:

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "command": "npx",
      "args": ["-y", "@migma/mcp"],
      "env": {
        "MIGMA_API_KEY": "your_migma_api_key"
      }
    }
  }
}
```

## Verify

Ask Copilot:

```text theme={null}
Show my Migma context and suggest what we should do first.
```

## Next

<CardGroup>
  <Card title="VS Code" icon="code-bracket-square" href="/agents/mcp-vscode">
    Editor-level MCP setup.
  </Card>

  <Card title="Setup Workflow" icon="plug" href="/setup">
    Agent-guided app wiring.
  </Card>
</CardGroup>


# Connect Migma MCP to Cursor
Source: https://docs.migma.ai/agents/mcp-cursor

Use Migma MCP in Cursor when you want an agent to prepare emails, review campaigns, manage contacts, or export approved work without leaving your editor.

Use Migma MCP in Cursor when you want an agent to prepare emails, review campaigns, manage contacts, or export approved work without leaving your editor.

## Option 1: Remote MCP

Use Remote MCP when Cursor supports Streamable HTTP servers with headers.

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "url": "https://migma.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MIGMA_API_KEY}"
      }
    }
  }
}
```

Add this to project-level `.cursor/mcp.json` or global Cursor MCP settings.

## Option 2: Local MCP

Use Local MCP when your Cursor setup cannot send remote headers.

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "command": "npx",
      "args": ["-y", "@migma/mcp"],
      "env": {
        "MIGMA_API_KEY": "your_migma_api_key"
      }
    }
  }
}
```

## Verify

Restart Cursor, then ask:

```text theme={null}
Use Migma to list my brands, then tell me which brand IDs are available.
```

If Cursor returns `projectId is required`, ask it to call `migma_list_projects` first and pass `projectId` to the next tool call.

## Next

<CardGroup>
  <Card title="MCP Server" icon="server" href="/mcp-server">
    Remote and local MCP details.
  </Card>

  <Card title="Agent Registration" icon="key" href="/agent-registration">
    Let Cursor request a scoped key without copy-paste.
  </Card>
</CardGroup>


# Connect Migma MCP to Raycast
Source: https://docs.migma.ai/agents/mcp-raycast

Use Migma MCP in Raycast AI when you want Quick AI or AI Chat to prepare emails, review campaigns, inspect contacts, or run safe Migma actions from your desktop.

Use Migma MCP in Raycast AI when you want Quick AI or AI Chat to prepare emails, review campaigns, inspect contacts, or run safe Migma actions from your desktop.

## Add MCP server

Use Raycast's MCP settings or MCP Registry extension to add a custom server. Raycast currently supports `stdio`, so use Local MCP:

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "command": "npx",
      "args": ["-y", "@migma/mcp"],
      "env": {
        "MIGMA_API_KEY": "your_migma_api_key"
      }
    }
  }
}
```

## Verify

Ask Raycast AI:

```text theme={null}
Use Migma to list my brands and show available tools.
```

## Next

<CardGroup>
  <Card title="MCP Server" icon="server" href="/mcp-server">
    Remote and local MCP details.
  </Card>

  <Card title="Agent Registration" icon="key" href="/agent-registration">
    Let an agent request scoped access.
  </Card>
</CardGroup>


# Connect Migma MCP to VS Code
Source: https://docs.migma.ai/agents/mcp-vscode

Connect Migma MCP to VS Code with remote or local configuration, verify brand access and available tools, and keep credentials and sends server-side.

Use Migma MCP in VS Code when your editor or agent extension supports MCP servers.

## Remote MCP

VS Code stores MCP servers in `mcp.json`, either in your user profile or in `.vscode/mcp.json` for a workspace.

```json theme={null}
{
  "inputs": [
    {
      "type": "promptString",
      "id": "migma-api-key",
      "description": "Migma API key",
      "password": true
    }
  ],
  "servers": {
    "migma": {
      "type": "http",
      "url": "https://migma.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${input:migma-api-key}"
      }
    }
  }
}
```

After editing the file, run **MCP: List Servers** or **MCP: Reset Cached Tools** from the Command Palette.

## Local MCP fallback

```json theme={null}
{
  "servers": {
    "migma": {
      "command": "npx",
      "args": ["-y", "@migma/mcp"],
      "env": {
        "MIGMA_API_KEY": "your_migma_api_key"
      }
    }
  }
}
```

## Verify

Ask your VS Code agent:

```text theme={null}
Show my Migma context and suggest what we should do first.
```

## Next

<CardGroup>
  <Card title="MCP Server" icon="server" href="/mcp-server">
    Remote and local MCP details.
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    Create or scope API keys.
  </Card>
</CardGroup>


# Connect Migma MCP to Windsurf
Source: https://docs.migma.ai/agents/mcp-windsurf

Connect Migma MCP to Windsurf Cascade through remote or local configuration, verify the available tools, and keep credentials and sending actions safe.

Use Migma MCP in Windsurf when Cascade should prepare, validate, export, or send Migma email work from your editor.

## Remote MCP

Add Migma from Windsurf settings or edit `~/.codeium/windsurf/mcp_config.json`:

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "serverUrl": "https://migma.ai/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MIGMA_API_KEY}"
      }
    }
  }
}
```

Restart Windsurf so Cascade reloads tools.

## Local MCP fallback

Use Local MCP if remote headers are not available:

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "command": "npx",
      "args": ["-y", "@migma/mcp"],
      "env": {
        "MIGMA_API_KEY": "your_migma_api_key"
      }
    }
  }
}
```

## Verify

Ask Cascade:

```text theme={null}
Use Migma to list my brands and show what tools are available.
```

## Next

<CardGroup>
  <Card title="MCP Server" icon="server" href="/mcp-server">
    Remote and local MCP details.
  </Card>

  <Card title="Agent Registration" icon="key" href="/agent-registration">
    Let agents request scoped access.
  </Card>
</CardGroup>


# Use Migma with AI tools
Source: https://docs.migma.ai/agents/overview

Plan in Claude, ChatGPT, Codex, or another AI tool while Migma handles brand, email design, review, and sending controls.

Keep working in the AI tool you already use. Migma brings the parts a chat draft does not have: lasting brand context, editable email design, a visual canvas, inbox checks, opted-in audiences, and controlled sending.

## Start with Claude or ChatGPT

<CardGroup>
  <Card title="Claude" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/tutorials/connect-migma-to-claude-code">
    Connect Claude Code or Claude Desktop, approve access, then create and review email work.
  </Card>

  <Card title="ChatGPT" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/tutorials/connect-migma-to-chatgpt">
    Connect the Migma plugin, ask with `@Migma`, and open finished drafts on the canvas.
  </Card>
</CardGroup>

## What Migma adds

<CardGroup>
  <Card title="Your real brand" icon="palette">
    Logos, colors, fonts, products, voice, saved references, and approved facts stay available between chats.
  </Card>

  <Card title="Editable email design" icon="pen-ruler">
    One request can become one email or a complete series you can edit on the Migma canvas.
  </Card>

  <Card title="Real inbox checks" icon="mobile-screen">
    Review Outlook, Gmail, Apple Mail, mobile, light mode, dark mode, links, and common sending problems.
  </Card>

  <Card title="Human approval" icon="shield-check">
    You approve live sends, schedules, audience changes, and exports.
  </Card>
</CardGroup>

## A normal workflow

<Steps>
  <Step title="Ask from your AI tool">
    Request a launch email, newsletter, welcome series, edit, audience check, or campaign draft in plain language.
  </Step>

  <Step title="Review the result in Migma">
    Open the canvas link to compare emails, change the design, and run inbox checks.
  </Step>

  <Step title="Approve what happens next">
    Ask for a test, prepare a campaign, export to your email platform, or send when the audience, sender, and timing are correct.
  </Step>
</Steps>

## More AI tools

<CardGroup>
  <Card title="Codex" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/codex.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=a4b7a9b1b86045262a76ff6dd3067637" href="/agents/mcp-codex">
    Use Migma from Codex CLI.
  </Card>

  <Card title="Cursor" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/cursor.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=1bc8ebb9727a9e7b6671d0c5a7dae482" href="/agents/mcp-cursor">
    Add Migma to Cursor projects.
  </Card>

  <Card title="Grok" icon="https://mintcdn.com/migmaai/D0Z-B44phiLBOsYh/images/logos/grok-bot.webp?fit=max&auto=format&n=D0Z-B44phiLBOsYh&q=85&s=3154724e3ec13fdf760e0b3cc4225509" href="/grok">
    Connect Grok Bot with guided setup.
  </Card>

  <Card title="Copilot" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/copilot.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=a1ae89d7f530a9604e469be973f465d4" href="/agents/mcp-copilot">
    Use Migma from VS Code or Copilot CLI.
  </Card>

  <Card title="Windsurf" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/windsurf.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=ebbece28d09dcab4e8a49b58e80e243c" href="/agents/mcp-windsurf">
    Connect Migma to Windsurf Cascade.
  </Card>

  <Card title="All supported clients" icon="grid-2" href="/mcp-server">
    See Migma setup for other compatible AI tools.
  </Card>
</CardGroup>

## Build Migma into an app

Use these guides when you want email work inside product code, backend jobs, or repeatable agent workflows.

<CardGroup>
  <Card title="MCP Server" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/mcp-server.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f5f7603fbb9a215d6bfd3b6390062008" href="/mcp-server">
    Connect supported AI tools through browser approval.
  </Card>

  <Card title="Skills" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/skill.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=16eaf6658a39a735ef9f2afd040eba19" href="/skills">
    Give coding agents repeatable Migma workflows.
  </Card>

  <Card title="Setup workflow" icon="plug" href="/setup">
    Ask an agent to find email triggers in an app and connect them to Migma.
  </Card>

  <Card title="Agent handoff" icon="copy" href="/agents/agent-handoff">
    Copy the right setup prompt from Migma into your coding agent.
  </Card>

  <Card title="Agent registration" icon="key" href="/agent-registration">
    Let a headless agent request limited access that you approve.
  </Card>

  <Card title="Security and permissions" icon="shield-check" href="/security/mcp">
    Review access, approval, and revocation before connecting.
  </Card>
</CardGroup>


# Migma Email Preview API
Source: https://docs.migma.ai/api-preview

Use the Migma Email Preview API to render HTML on real devices and clients including Gmail, Outlook, Apple Mail, iOS, and Android before sending.

## Overview

The Email Preview API generates screenshots of your email HTML on real devices and email clients. Preview Gmail, Outlook, Apple Mail, mobile apps, and other supported platforms before send.

<Warning>
  **Credit Cost:** Each email preview request costs **2 credits**. Make sure you have sufficient credits before generating previews.
</Warning>

## Features

* **Many clients and devices**: Gmail, Outlook, Apple Mail, Yahoo, iOS and Android mail apps, and more
* **Real Device Rendering**: Screenshots from actual devices, not simulators
* **Mobile & Desktop**: Preview on iPhone, Android, iPad, desktop clients
* **Fast Generation**: Results typically ready in 60-90 seconds
* **High-Quality Screenshots**: Full-resolution images of your email renders

## How It Works

1. **Create Preview**: Send your email HTML to the preview endpoint
2. **Processing**: Your email is rendered on real devices (60-90 seconds)
3. **Get Results**: Retrieve high-quality screenshots for each device

## Pricing

<Card title="Credit Usage" icon="coins">
  Each preview request costs **2 credits**, regardless of how many devices you select. The default is 10 common devices; pass a `devices` array or list IDs from `/v1/emails/devices/supported`.
</Card>

## Quick Start

### 1. Create a Preview

```typescript Node.js SDK theme={null}
import Migma from 'migma';
const migma = new Migma(process.env.MIGMA_API_KEY);

// createAndWait polls until all device screenshots are ready
const { data } = await migma.previews.createAndWait({
  html: '<html><body><h1>Test Email</h1></body></html>',
  subject: 'My Email Preview',
  name: 'Homepage Newsletter'
});

for (const device of data.devices) {
  console.log(`${device.deviceName}: ${device.screenshotUrl}`);
}
```

```bash cURL theme={null}
curl -X POST https://api.migma.ai/v1/emails/previews \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "html": "<html><body><h1>Test Email</h1></body></html>",
    "subject": "My Email Preview",
    "name": "Homepage Newsletter"
  }'
```

**Response:**

```json theme={null}
{
  "success": true,
  "data": {
    "previewId": "preview_abc123",
    "status": "processing",
    "creditsCharged": 2
  }
}
```

### 2. Check Preview Status

```bash theme={null}
curl -X GET https://api.migma.ai/v1/emails/previews/preview_abc123 \
  -H "Authorization: Bearer YOUR_API_KEY"
```

**Response (Processing):**

```json theme={null}
{
  "success": true,
  "data": {
    "previewId": "preview_abc123",
    "status": "processing",
    "progress": 45
  }
}
```

**Response (Complete):**

```json theme={null}
{
  "success": true,
  "data": {
    "previewId": "preview_abc123",
    "status": "completed",
    "previews": [
      {
        "device": "gmail-chrome",
        "imageUrl": "https://cdn.migma.ai/previews/...",
        "platform": "desktop"
      },
      {
        "device": "iphone-14-pro",
        "imageUrl": "https://cdn.migma.ai/previews/...",
        "platform": "mobile"
      }
    ]
  }
}
```

### 3. Get Supported Devices

```bash theme={null}
curl -X GET https://api.migma.ai/v1/emails/devices/supported \
  -H "Authorization: Bearer YOUR_API_KEY"
```

## Request Parameters

| Parameter | Type | Required | Description |
| - | - | - | - |
| `html` | string | Yes | Email HTML content to preview |
| `subject` | string | No | Email subject line (default: "Email Preview") |
| `devices` | array | No | Specific devices to render on (defaults to 10 common devices) |
| `name` | string | No | Custom name for the preview |

## Default Devices

When you don't specify devices, previews are generated on these 10 platforms:

* Gmail (Chrome Desktop)
* Gmail (Android App)
* Outlook 2016 (Windows)
* Outlook.com (Browser)
* Apple Mail (macOS)
* Apple Mail (iPhone 14)
* Yahoo Mail (Browser)
* Samsung Email (Android)
* Outlook iOS App
* Gmail iOS App

## Custom Device Selection

You can specify exactly which devices to use:

```bash theme={null}
curl -X POST https://api.migma.ai/v1/emails/previews \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "html": "<html>...</html>",
    "devices": [
      "gmail-chrome",
      "outlook-2016",
      "iphone-14-pro",
      "gmail-android"
    ]
  }'
```

<Tip>
  List every supported device ID with `GET /v1/emails/devices/supported`.
</Tip>

## Response Statuses

| Status | Description |
| - | - |
| `processing` | Preview is being generated |
| `completed` | All screenshots are ready |
| `failed` | Preview generation failed |

## Common Use Cases

### Quality Assurance

Test emails before sending campaigns to ensure they render correctly across all platforms.

### Client Approval

Generate previews to show clients how emails will look on different devices.

### Responsive Testing

Verify that your email design is mobile-friendly and responsive.

### Cross-Platform Compatibility

Identify rendering issues specific to certain email clients.

## Best Practices

<AccordionGroup>
  <Accordion title="Optimize Your HTML">
    Ensure your email HTML is valid and uses email-safe CSS. Avoid modern CSS features that may not be supported in all email clients.
  </Accordion>

  <Accordion title="Test on Key Platforms">
    Focus on the email clients your audience actually uses. Check your email analytics to see which platforms are most common.
  </Accordion>

  <Accordion title="Monitor Credit Usage">
    Each preview costs 2 credits. Plan your testing workflow to minimize unnecessary preview generations.
  </Accordion>

  <Accordion title="Cache Results">
    Store preview images for reference. You can reuse them for client presentations without regenerating.
  </Accordion>
</AccordionGroup>

## Error Handling

### Insufficient Credits

```json theme={null}
{
  "success": false,
  "error": "Insufficient credits. This operation requires 2 credits.",
  "code": "INSUFFICIENT_CREDITS"
}
```

<Info>
  Check your credit balance before generating previews. You can view your balance in your account dashboard or via the API.
</Info>

### Invalid HTML

```json theme={null}
{
  "success": false,
  "error": "Invalid HTML content provided",
  "code": "INVALID_HTML"
}
```

## Limitations

* **Processing Time**: Previews typically take 60-90 seconds to generate
* **HTML Size**: Maximum HTML size is 500KB
* **Rate Limits**: Subject to your plan's rate limits
* **Image Assets**: External images must be publicly accessible

## Need Help?

<CardGroup>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    View complete API documentation
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    Learn about API keys
  </Card>

  <Card title="Events & Webhooks" icon="bolt" href="/webhooks">
    Get notified when API events occur
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Get help from our community
  </Card>
</CardGroup>


# Create Upgrade Link
Source: https://docs.migma.ai/api-reference/billing/create-upgrade-link

/api-reference/openapi.json post /v1/billing/upgrade-link
Create a new-subscription checkout URL for a user-chosen plan, or omit plan to get the existing Stripe customer's billing portal (returns 400 otherwise). Passing plan for an active existing subscription can change its plan and charge a prorated payment immediately; obtain explicit approval for that charge. The returned URL may be a checkout, hosted invoice, confirmation, or billing portal URL and alone does not confirm payment. Requires API key with billing:write permission.



# Get Credits
Source: https://docs.migma.ai/api-reference/billing/get-credits

/api-reference/openapi.json get /v1/billing/credits
Get the current plan and remaining email, image, and monthly credits for the API key owner. Requires API key with billing:read permission.



# Archive Campaign
Source: https://docs.migma.ai/api-reference/campaigns/archive-campaign

/api-reference/openapi.json post /v1/campaigns/{id}/archive
Archive a campaign to hide it from the default campaign list. Works for any status. Archived campaigns are excluded from list results unless the archived filter is set. Requires API key with campaign:write.



# Cancel Campaign
Source: https://docs.migma.ai/api-reference/campaigns/cancel-campaign

/api-reference/openapi.json post /v1/campaigns/{id}/cancel
Cancel an eligible campaign. The returned campaign has status cancelled. Requires API key with campaign:write.



# Create Campaign
Source: https://docs.migma.ai/api-reference/campaigns/create-campaign

/api-reference/openapi.json post /v1/campaigns
Create a new email campaign from a generated email. Use emailId for the exact generated email, especially series slots. Requires API key with campaign:write.



# Get Campaign
Source: https://docs.migma.ai/api-reference/campaigns/get-campaign

/api-reference/openapi.json get /v1/campaigns/{id}
Get a single campaign by ID. Requires API key with campaign:read.



# Get Campaign Logs
Source: https://docs.migma.ai/api-reference/campaigns/get-campaign-logs

/api-reference/openapi.json get /v1/campaigns/{id}/logs
List per-recipient delivery and engagement logs for a campaign, newest first. Cursor-paginated. Rows come from the tracking worker (D1) and use snake_case field names. Requires API key with campaign:read.



# Get Campaign Stats
Source: https://docs.migma.ai/api-reference/campaigns/get-campaign-stats

/api-reference/openapi.json get /v1/campaigns/{id}/stats
Get aggregate engagement stats for a sent campaign (sends, deliveries, opens, clicks, unsubscribes, bounces, and rates). Stats are sourced from the tracking worker and may be cached and slightly stale. botOpens, botClicks, and mppOpens reflect Apple Mail Privacy Protection and bot detection when available. Requires API key with campaign:read.



# List Campaigns
Source: https://docs.migma.ai/api-reference/campaigns/list-campaigns

/api-reference/openapi.json get /v1/campaigns
List campaigns for a project. Requires API key with campaign:read.



# Schedule Campaign
Source: https://docs.migma.ai/api-reference/campaigns/schedule-campaign

/api-reference/openapi.json post /v1/campaigns/{id}/schedule
Schedule a campaign for future delivery. scheduledAt must be in the future. Requires API key with campaign:write.



# Send Campaign
Source: https://docs.migma.ai/api-reference/campaigns/send-campaign

/api-reference/openapi.json post /v1/campaigns/{id}/send
Send a draft or scheduled campaign immediately. Re-extracts the latest template at send time. Requires API key with campaign:write.



# Unarchive Campaign
Source: https://docs.migma.ai/api-reference/campaigns/unarchive-campaign

/api-reference/openapi.json post /v1/campaigns/{id}/unarchive
Restore a previously archived campaign, making it visible in the default list again. Requires API key with campaign:write.



# Add Contact
Source: https://docs.migma.ai/api-reference/contacts/add-contact

/api-reference/openapi.json post /v1/contacts
Add a single contact. Requires API key with audience:write.



# Batch Delete Contacts
Source: https://docs.migma.ai/api-reference/contacts/batch-delete-contacts

/api-reference/openapi.json post /v1/contacts/bulk-delete
Delete up to 1000 contacts by email in a single request. Requires API key with audience:write. Partial-success-safe: emails with no matching contact are returned in `notFound`, never treated as errors.



# Bulk Import Contacts
Source: https://docs.migma.ai/api-reference/contacts/bulk-import-contacts

/api-reference/openapi.json post /v1/contacts/bulk
Bulk import contacts. Requires API key with audience:write.



# Change Contact Status
Source: https://docs.migma.ai/api-reference/contacts/change-contact-status

/api-reference/openapi.json post /v1/contacts/status
Change a contact's subscription status by email. Requires API key with audience:write.



# Create Contact Export
Source: https://docs.migma.ai/api-reference/contacts/create-contact-export

/api-reference/openapi.json post /v1/contacts/exports
Queue a full filtered CSV export. Requires audience:read and brand ownership. Returns 202 only after enqueue. Poll exact job for download URL; no email is sent by this API. Idempotency-Key replay uses a stable queue job ID and rejects different request bodies. Jobs retained up to seven days. Filters use tag IDs. Export does not synchronize external services.



# Create Contact Import
Source: https://docs.migma.ai/api-reference/contacts/create-contact-import

/api-reference/openapi.json post /v1/contacts/imports
Import contacts from an uploaded CSV file. The file is stored and processed in the background; poll `GET /v1/contacts/imports/{id}` for status and counts. Requires API key with audience:write.



# Create Provider Contact Import
Source: https://docs.migma.ai/api-reference/contacts/create-provider-contact-import

/api-reference/openapi.json post /v1/contacts/imports/provider
Import contacts from one or more sources on a connected Klaviyo, Mailchimp, or HubSpot account. Processing runs in the background; poll `GET /v1/contacts/imports/{id}` for status and counts. Each import creates a tag and a saved segment named after the source(s). Unsubscribed contacts stay unsubscribed. Requires API key with audience:write.



# Delete Contact
Source: https://docs.migma.ai/api-reference/contacts/delete-contact

/api-reference/openapi.json delete /v1/contacts/{id}
Delete a contact. Requires API key with audience:write.



# Get Bulk Import Status
Source: https://docs.migma.ai/api-reference/contacts/get-bulk-import-status

/api-reference/openapi.json get /v1/contacts/bulk/{jobId}
Poll an async JSON bulk import job. Requires API key with audience:read.



# Get Contact
Source: https://docs.migma.ai/api-reference/contacts/get-contact

/api-reference/openapi.json get /v1/contacts/{id}
Get a single contact by ID. Requires API key with audience:read.



# Get Contact Export
Source: https://docs.migma.ai/api-reference/contacts/get-contact-export

/api-reference/openapi.json get /v1/contacts/exports/{jobId}
Requires audience:read, current brand ownership and same requester as job. Completed returns actual row count and fresh one-hour private CSV URL. Missing or expired jobs return 404, not zero contacts.



# Get Contact Import
Source: https://docs.migma.ai/api-reference/contacts/get-contact-import

/api-reference/openapi.json get /v1/contacts/imports/{id}
Get a contact import's status and counts for CSV and provider imports. Provider imports include `provider`, `tag_id`, `segment_id`, and `counts.non_sendable`. Requires API key with audience:read.



# List Contacts
Source: https://docs.migma.ai/api-reference/contacts/list-contacts

/api-reference/openapi.json get /v1/contacts
List contacts for a project. Requires API key with audience:read.



# List Provider Import Sources
Source: https://docs.migma.ai/api-reference/contacts/list-provider-import-sources

/api-reference/openapi.json get /v1/contacts/imports/providers/{provider}/sources
List audiences, lists, segments, and tags available to import from a connected Klaviyo, Mailchimp, or HubSpot account. Requires API key with audience:read and brand access. Pass `connectionId` when more than one account is connected for the provider.



# Update Contact
Source: https://docs.migma.ai/api-reference/contacts/update-contact

/api-reference/openapi.json patch /v1/contacts/{id}
Update a contact's details. Requires API key with audience:write.



# Add DNS Record
Source: https://docs.migma.ai/api-reference/domains/add-dns-record

/api-reference/openapi.json post /v1/domains/{domain}/dns-records
Add a DNS record to a domain bought in Migma, for example Google Workspace MX records, a site-verification TXT, or an A record pointing a subdomain at a server. Migma's email sending records are protected and managed automatically, duplicate SPF or DMARC records are refused, the root and www names are reserved for domain forwarding, and each domain is capped at 50 records. Returns 404 if the domain's DNS zone is not hosted by Migma. Requires API key with domain:write permission.



# Add Domain
Source: https://docs.migma.ai/api-reference/domains/add-domain

/api-reference/openapi.json post /v1/domains
Add a new sending domain. Returns DNS records that must be configured for verification. Requires API key with domain:write.



# Check Subdomain Availability
Source: https://docs.migma.ai/api-reference/domains/check-subdomain-availability

/api-reference/openapi.json get /v1/domains/managed/check/{prefix}
Check if a managed subdomain prefix is available on migma.email. Requires API key with domain:read.



# Create Managed Domain
Source: https://docs.migma.ai/api-reference/domains/create-managed-domain

/api-reference/openapi.json post /v1/domains/managed
Create a managed subdomain on migma.email. The domain is instantly verified with no DNS setup required. Requires API key with domain:write.



# Delete Domain
Source: https://docs.migma.ai/api-reference/domains/delete-domain

/api-reference/openapi.json delete /v1/domains/{domain}
Delete a sending domain. Requires API key with domain:write.



# Delete Managed Domain
Source: https://docs.migma.ai/api-reference/domains/delete-managed-domain

/api-reference/openapi.json delete /v1/domains/managed/{domain}
Delete a managed subdomain. Requires API key with domain:write.



# Get Domain
Source: https://docs.migma.ai/api-reference/domains/get-domain

/api-reference/openapi.json get /v1/domains/{domain}
Get domain details by domain name. Requires API key with domain:read.



# List DNS Records
Source: https://docs.migma.ai/api-reference/domains/list-dns-records

/api-reference/openapi.json get /v1/domains/{domain}/dns-records
List DNS records on a domain whose DNS zone is hosted by Migma. Only domains bought in Migma have Migma-hosted zones; for other domains managed is false and records is empty. Requires API key with domain:read permission.



# List Domain Purchases
Source: https://docs.migma.ai/api-reference/domains/list-domain-purchases

/api-reference/openapi.json get /v1/domains/purchase/registrations
List domain purchases and their registration status. Status moves from payment_pending to registering to active, or to failed or refunded. Requires API key with domain:read permission.



# List Domains
Source: https://docs.migma.ai/api-reference/domains/list-domains

/api-reference/openapi.json get /v1/domains
List all sending domains for the authenticated user. Requires API key with domain:read.



# List Managed Domains
Source: https://docs.migma.ai/api-reference/domains/list-managed-domains

/api-reference/openapi.json get /v1/domains/managed
List all managed subdomains (migma.email) for the authenticated user. Requires API key with domain:read.



# Provision Stream Identity
Source: https://docs.migma.ai/api-reference/domains/provision-stream-identity

/api-reference/openapi.json post /v1/domains/streams
Provision a transactional or marketing sending identity on a domain you own. Creates notify.<rootDomain> (transactional) or send.<rootDomain> (marketing) to isolate transactional reputation from marketing. Returns DNS records to publish, then verify. Requires API key with domain:write.



# Purchase Domain
Source: https://docs.migma.ai/api-reference/domains/purchase-domain

/api-reference/openapi.json post /v1/domains/purchase
Start a domain purchase. Returns a Stripe checkout URL the account owner opens and pays in a browser. Domains are billed yearly and renew automatically. The domain registers only after payment clears, and failed registrations are refunded automatically. Requires an active paid Migma subscription (returns 409 otherwise) and an API key with domain:write permission.



# Remove DNS Record
Source: https://docs.migma.ai/api-reference/domains/remove-dns-record

/api-reference/openapi.json delete /v1/domains/{domain}/dns-records/{recordId}
Remove a DNS record that was added to a domain bought in Migma. Only removes records the user added, never Migma's own sending records. Requires API key with domain:write permission.



# Search Buyable Domains
Source: https://docs.migma.ai/api-reference/domains/search-buyable-domains

/api-reference/openapi.json get /v1/domains/purchase/search
Check availability and yearly price for domains matching a query. Requires API key with domain:read permission.



# Set Up Domain
Source: https://docs.migma.ai/api-reference/domains/set-up-domain

/api-reference/openapi.json post /v1/domains/setup
Provision the main sending identity (bare root domain) and notify.<rootDomain> (transactional) on a domain you own in one call. The main identity is used for campaigns and hand sends; notify.<rootDomain> is for receipts and password resets. If a legacy send.<rootDomain> marketing identity already exists, it is included in the response; new setups do not create marketing. Idempotent. Safe to call again if DNS records already exist. Returns DNS records for each provisioned identity. Requires API key with domains:write.



# Update Domain Settings
Source: https://docs.migma.ai/api-reference/domains/update-domain-settings

/api-reference/openapi.json patch /v1/domains/{domain}
Update domain tracking settings. Requires API key with domain:write.



# Verify Domain
Source: https://docs.migma.ai/api-reference/domains/verify-domain

/api-reference/openapi.json post /v1/domains/{domain}/verify
Trigger DNS verification for a domain. Returns current verification status. Requires API key with domain:write.



# Create Email Preview
Source: https://docs.migma.ai/api-reference/email-previews/create-email-preview

/api-reference/openapi.json post /v1/emails/previews
Generate email previews from HTML rendered on real devices and email clients (Gmail, Outlook, Apple Mail, mobile apps, and other supported platforms).

**💳 Credit Cost:** Each preview request costs **2 credits**.



# Get Preview Status and Results
Source: https://docs.migma.ai/api-reference/email-previews/get-preview-status-and-results

/api-reference/openapi.json get /v1/emails/previews/{previewId}
Retrieve the current status and complete results of an email preview, including all device screenshots. Note: This endpoint only retrieves results; credits (2 credits) are charged when creating the preview via POST /v1/emails/previews.



# Get Preview Status Only
Source: https://docs.migma.ai/api-reference/email-previews/get-preview-status-only

/api-reference/openapi.json get /v1/emails/previews/{previewId}/status
Lightweight endpoint to check preview status without downloading full preview data. Optimized for polling.



# Get Specific Device Preview
Source: https://docs.migma.ai/api-reference/email-previews/get-specific-device-preview

/api-reference/openapi.json get /v1/emails/previews/{previewId}/devices/{deviceKey}
Get the preview screenshot for a single device.



# Get Supported Devices
Source: https://docs.migma.ai/api-reference/email-previews/get-supported-devices

/api-reference/openapi.json get /v1/emails/devices/supported
List device IDs available for email preview, grouped by platform (desktop, mobile, web).



# Analyze Email Deliverability
Source: https://docs.migma.ai/api-reference/email-validation/analyze-email-deliverability

/api-reference/openapi.json post /v1/emails/validate/deliverability
Predict email deliverability and inbox placement (Inbox/Promotions/Spam) based on content analysis.



# Analyze Email Links
Source: https://docs.migma.ai/api-reference/email-validation/analyze-email-links

/api-reference/openapi.json post /v1/emails/validate/links
Check all links in email HTML for validity and responsiveness. Identifies broken links, slow-loading resources, and unreachable URLs.



# Check Email Compatibility
Source: https://docs.migma.ai/api-reference/email-validation/check-email-compatibility

/api-reference/openapi.json post /v1/emails/validate/compatibility
Test email HTML on major webmail, desktop, and mobile clients and return a compatibility report. Flags rendering issues in Gmail, Outlook, Apple Mail, and other supported clients.



# Check Spelling & Grammar
Source: https://docs.migma.ai/api-reference/email-validation/check-spelling-&-grammar

/api-reference/openapi.json post /v1/emails/validate/spelling
AI-powered spell checking, grammar analysis, and content quality assessment for email content.



# Run All Validation Checks
Source: https://docs.migma.ai/api-reference/email-validation/run-all-validation-checks

/api-reference/openapi.json post /v1/emails/validate/all
Run all validation checks (compatibility, links, spelling, deliverability) in a single request for comprehensive email analysis.



# Edit Email With Prompt
Source: https://docs.migma.ai/api-reference/emails/edit-email-with-prompt

/api-reference/openapi.json post /v1/emails/{emailId}/edit
Prompt Migma to edit one generated email as a canvas follow-up turn (same orchestrator path as design chat). Omit async or set it to false to wait for the edited Email response; this existing synchronous write is not idempotent and the SDK does not automatically retry it. Set async to true to durably enqueue the edit with no AI work on the request path and receive an EmailEditOperation. Async edits require email:write and email:read; credits are checked when the worker starts. Poll the edit-specific status endpoint and do not use conversation generation status, because a previous conversation turn may already be completed. Total work varies with section and image complexity, provider behavior, and retries; no fixed maximum latency is established.



# Export HTML
Source: https://docs.migma.ai/api-reference/emails/export-html

/api-reference/openapi.json get /v1/export/html/{conversationId}
Export conversation as standard HTML.



# Export HubSpot
Source: https://docs.migma.ai/api-reference/emails/export-hubspot

/api-reference/openapi.json post /v1/export/hubspot
Export conversation as HubSpot-compatible HTML and HubL files.



# Export Klaviyo
Source: https://docs.migma.ai/api-reference/emails/export-klaviyo

/api-reference/openapi.json get /v1/export/klaviyo/{conversationId}
Export conversation as Klaviyo-compatible HTML with editable regions.



# Export Mailchimp
Source: https://docs.migma.ai/api-reference/emails/export-mailchimp

/api-reference/openapi.json get /v1/export/mailchimp/{conversationId}
Export conversation as Mailchimp-compatible HTML. Returns URLs for file downloads.



# Export PDF
Source: https://docs.migma.ai/api-reference/emails/export-pdf

/api-reference/openapi.json get /v1/export/pdf/{conversationId}
Export conversation as a PDF document. Returns a download URL.



# Export PNG
Source: https://docs.migma.ai/api-reference/emails/export-png

/api-reference/openapi.json get /v1/export/png/{conversationId}
Export conversation as a PNG image of the email. Returns a download URL.



# Generate Email (Async)
Source: https://docs.migma.ai/api-reference/emails/generate-email-async

/api-reference/openapi.json post /v1/projects/emails/generate
Generate one email or a multi-email series for a project using its brand context and optional images. Requires API key with email:write. Provide count (1-12) to request a specific series length, or omit it to infer from the prompt. Returns immediately with a conversationId and pending status. Use GET /v1/projects/emails/{conversationId}/status to retrieve production HTML, screenshots, and per-email IDs.



# Get Batch Status
Source: https://docs.migma.ai/api-reference/emails/get-batch-status

/api-reference/openapi.json get /v1/sending/batches/{batchId}
Get the status of a batch email send. Requires API key with email:read.



# Get Email
Source: https://docs.migma.ai/api-reference/emails/get-email

/api-reference/openapi.json get /v1/emails/{emailId}
Fetch one generated email by emailId. Returns production-ready HTML, subject, preheader, and screenshot URLs.



# Get Email Edit Status
Source: https://docs.migma.ai/api-reference/emails/get-email-edit-status

/api-reference/openapi.json get /v1/emails/{emailId}/edits/{editId}
Get the exact queued edit status. Requires email:read and ownership of the email. A completed response includes the current saved Email in result. A failed response includes error and changesMayHaveBeenSaved; inspect the stored email before starting another edit. Failed or stalled jobs are not automatically rewritten. Do not infer this edit's status from conversation generation status.



# Get Email Generation Status
Source: https://docs.migma.ai/api-reference/emails/get-email-generation-status

/api-reference/openapi.json get /v1/projects/emails/{conversationId}/status
Check email generation status. When completed, returns primary email HTML plus result.emails[] for every generated email, including emailId, subject, HTML, screenshot URL, and series order.



# Get Email Logs
Source: https://docs.migma.ai/api-reference/emails/get-email-logs

/api-reference/openapi.json get /v1/emails/{emailId}/logs
Per-recipient send log for one generated email, cursor-paginated. Filter by status. Returns { emails, nextCursor, hasMore }. Individual rows are retained roughly 30 days. Requires the email:read scope.



# Get Email Metrics
Source: https://docs.migma.ai/api-reference/emails/get-email-metrics

/api-reference/openapi.json get /v1/emails/{emailId}/metrics
Aggregate performance for one generated email across every API send of it: delivery, opens, clicks, bounces, complaints, unsubscribes, plus a daily time series and country breakdown. Numbers arrive asynchronously and cover roughly the last 30 days of raw history (aggregates persist longer). Opens are directional — Apple Mail Privacy Protection and bots inflate them; clicks and delivery events are stronger signals. Requires the email:read scope.



# Get Export Status
Source: https://docs.migma.ai/api-reference/emails/get-export-status

/api-reference/openapi.json get /v1/export/status/{conversationId}
Check export availability for a conversation



# Get Sending Metrics
Source: https://docs.migma.ai/api-reference/emails/get-sending-metrics

/api-reference/openapi.json get /v1/metrics/sending
Get account-level sending totals, quota usage, and optional monthly history. Requires API key with email:read permission.



# Import HTML Email (Async)
Source: https://docs.migma.ai/api-reference/emails/import-html-email-async

/api-reference/openapi.json post /v1/projects/emails/import-html
Convert existing HTML or .eml into editable Migma emails using the same HTML to Email path as Create. Requires API key with email:write. Provide html for one file or htmls (1-12). Optional instruction describes keep-as-is vs apply-brand. Returns immediately with a conversationId and pending status. Use GET /v1/projects/emails/{conversationId}/status to retrieve production HTML, screenshots, and per-email IDs. Do not send HTML to generate.



# List Emails
Source: https://docs.migma.ai/api-reference/emails/list-emails

/api-reference/openapi.json get /v1/projects/emails
List emails (conversations) for a project. Returns lightweight metadata including subject, status, and screenshot URL.



# List Export Formats
Source: https://docs.migma.ai/api-reference/emails/list-export-formats

/api-reference/openapi.json get /v1/export/formats
Get available export formats



# Send Email
Source: https://docs.migma.ai/api-reference/emails/send-email

/api-reference/openapi.json post /v1/sending
Send one generated email to a single recipient, audience, segment, or tag. Provide emailId to send a specific email from a conversation or series. conversationId remains supported for single-email conversations. Single-recipient requests await provider acceptance and return status sent; audience, segment, and tag sends are queued and return status queued. Native sends share account, domain, and AWS regional throughput limits. A single-recipient request can return 429 with code SENDING_CAPACITY and data.retryAfterMs when capacity is exhausted or unavailable. Wait at least that long before retrying. Queued native sends wait automatically without consuming retry attempts. Single-recipient sends are transactional by default; batch sends default to marketing. Requires API key with email:send.



# Send Test Email
Source: https://docs.migma.ai/api-reference/emails/send-test-email

/api-reference/openapi.json post /v1/emails/test/send
Send a test email to one address. Use emailId for a specific generated email, especially emails inside a series. conversationId remains supported for single-email conversations. Requires API key with email:send permission.



# Track Event
Source: https://docs.migma.ai/api-reference/events/track-event

/api-reference/openapi.json post /v1/events
Record a customer event for a project. Requires the audience:write permission. Contact resolution is consent safe: profile fields may update, subscription status never changes. Send an Idempotency-Key header (or a body dedupeKey) for replay safety; without either, every call stores a distinct event. Events carrying identifiers.externalOrderId and a numeric properties.value are recorded as conversions attributed to the last email the contact clicked within five days.



# Track Events (Batch)
Source: https://docs.migma.ai/api-reference/events/track-events-batch

/api-reference/openapi.json post /v1/events/batch
Record up to 500 events in one request with row-level partial success: one malformed row never fails the batch. Idempotency is per row via dedupeKey; a request-level Idempotency-Key header is rejected. Aggregate properties payloads are limited to 1MB.



# Connect Shopify Store
Source: https://docs.migma.ai/api-reference/integrations/connect-shopify-store

/api-reference/openapi.json post /v1/shopify/connect
Connect a Shopify store to a project. Requires API key with email:read permission.



# Migma Email API Reference
Source: https://docs.migma.ai/api-reference/introduction

The Migma.ai API provides programmatic access to our AI Email Engine that creates pixel-perfect, on-brand emails in 30 seconds.

## Overview

The Migma.ai API provides programmatic access to our AI Email Engine that creates pixel-perfect, on-brand emails in 30 seconds. Build custom integrations, automate email creation workflows, track customer events, export to platforms like Mailchimp and HubSpot, and manage your entire email marketing infrastructure programmatically.

Generate emails 200x faster and 95% cheaper with AI that learns your brand voice, fetches live content, and creates cross-client compatible HTML.

## Base URL

All API requests should be made to:

```text theme={null}
https://api.migma.ai
```

## Authentication

All API endpoints require a bearer token. Get one with `migma login`, hosted MCP OAuth, or [agent registration](/agent-registration). CI sets `MIGMA_API_KEY`. Include it in the `Authorization` header:

```http theme={null}
Authorization: Bearer YOUR_API_KEY
```

<Card title="Authentication Guide" icon="key" href="/authentication">
  Learn how to create and manage API keys
</Card>

## API structure

The Migma.ai API is organized around REST principles:

* **Predictable resource-oriented URLs**
* **Standard HTTP response codes**
* **JSON request and response bodies**
* **Bearer token authentication**

## Request format

All `POST`, `PATCH`, and `PUT` requests should use JSON format:

```http theme={null}
Content-Type: application/json
```

Example request:

```bash theme={null}
curl -X POST https://api.migma.ai/v1/projects/import \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://yourbrand.com"], "name": "My Brand"}'
```

## Response format

All API responses follow a consistent structure:

### Success response

```json theme={null}
{
  "success": true,
  "data": {
    // Response data here
  },
  "metadata": {
    "timestamp": "2024-09-30T12:34:56.789Z",
    "requestId": "req_1234567890"
  }
}
```

### Error response

```json theme={null}
{
  "success": false,
  "error": "Error message describing what went wrong"
}
```

## HTTP status codes

The API uses standard HTTP status codes:

| Code | Meaning | Description |
| - | - | - |
| `200` | OK | Request succeeded |
| `201` | Created | Resource was created successfully |
| `400` | Bad Request | Invalid request parameters |
| `401` | Unauthorized | Invalid or missing API key |
| `403` | Forbidden | API key lacks required permissions |
| `404` | Not Found | Resource doesn't exist |
| `429` | Too Many Requests | Rate limit exceeded |
| `500` | Internal Server Error | Something went wrong on our end |
| `503` | Service Unavailable | Service temporarily unavailable |

## Rate limiting

API request allowances follow your account's plan. All API keys belonging to the
same account share each route group's budget, including keys used by separate
applications or agents. Creating another key does not increase that allowance.

| Limit | What it counts | How it is set |
| - | - | - |
| General API requests | Requests within each general route group | Your plan's API requests per minute, with any account override |
| Sending API requests | All requests under `/v1/sending`, including batch status and retry | At least 60 × your account's recipients/second limit, or a higher configured plan allowance; an explicit account override takes priority |
| Sending throughput | Recipients dispatched per second across campaigns and direct sends | Your account and sending-domain limits, plus available provider capacity |
| Sending volume | Recipients sent per day or month | Your plan's email allowance and applicable domain limits |

For example, an account capped at **5 recipients/second** receives at least
**300 sending API requests/minute** without an account-specific API override.
An account capped at **300 recipients/second** receives at least **18,000
requests/minute**. These examples describe request allowances, not guaranteed
processing speed. A configured zero allowance disables the corresponding API
budget; it does not mean unlimited.

Find your effective allowances in **Settings → Developers → API Keys → API
limits**. Annual plans use their configured plan limits. Account-specific
agreements can change the displayed allowance.

Request budgets use a **60-second window starting with its first request**.
Pace requests throughout the minute: using the entire request budget at once
does not bypass recipient/second limits. This limiter has no separate daily
request quota or extra burst allowance. Email daily/monthly quotas still apply.

Email reading, editing, and test previews under `/v1/emails` use the general
plan allowance in a separate group, so they do not consume the `/v1/sending`
budget. Campaign endpoints have their own general-plan group. Expensive
operations such as imports can have a lower endpoint-specific cap. Requests
that reach a limiter count even if later validation fails or an idempotent
response is replayed.

Responses that reach the request limiter include these headers. Values below
are illustrative:

```http theme={null}
X-RateLimit-Limit: 300
X-RateLimit-Remaining: 295
X-RateLimit-Reset: 1609459200
```

`X-RateLimit-Reset` is a Unix timestamp in seconds. When the request budget is
exhausted, the API returns HTTP `429` and `Retry-After`, expressed in seconds:

```json theme={null}
{
  "success": false,
  "error": "Rate limit exceeded. Please try again later."
}
```

If the shared request limiter or account-limit lookup is unavailable, the API
returns HTTP `503` with `Retry-After: 1` before running the endpoint.

Actual sending capacity is checked separately. A direct send can return `429`
with `code: "SENDING_CAPACITY"` and `data.retryAfterMs` even when request budget
remains. Campaign recipients wait for available capacity in the sending queue.
One audience-send request can create many deliveries; every recipient still
counts against throughput and volume limits.

<Tip>
  On a request-limit response, wait for `Retry-After`. On a sending-capacity
  response, wait for `data.retryAfterMs`. Retry the same send with the same API
  key, body, and `Idempotency-Key`; use bounded retries with backoff and jitter.
</Tip>

## Pagination

List endpoints support pagination using `limit` and `offset` parameters:

```bash theme={null}
GET /v1/projects?limit=20&offset=0
```

Response includes pagination metadata:

```json theme={null}
{
  "success": true,
  "data": {
    "projects": [...],
    "total": 45,
    "limit": 20,
    "offset": 0
  }
}
```

## Idempotency

`POST` endpoints accept an optional `Idempotency-Key` request header so you can safely retry a request after a network error or timeout without doing the work twice. It is opt-in: a request without the header is processed normally.

```http theme={null}
Idempotency-Key: campaign-send-camp_123
```

The header is a string up to 100 characters. Keys are scoped per API key, so the same key used by two different keys never collides.

### Replay behavior

Within a 24 hour window, the first request with a given key runs normally and its response is cached. After that:

* **Same key and same body** returns the original cached response, with the same status and body. The replay carries the response header `Idempotent-Replayed: true`, so you can tell a replay from a fresh execution.
* **Same key but a different body** returns `409` with `error` code `IDEMPOTENCY_CONFLICT`. Mint a fresh key whenever the request genuinely changes.
* **A key longer than 100 characters** is rejected with `400` and code `IDEMPOTENCY_KEY_INVALID`.

`429` (rate limited) and `5xx` (server) responses are **not** cached, so a retry with the same key runs again. This is what makes a retry after a transient failure safe.

* **A request still running with the same key** returns `503` with code `IDEMPOTENCY_IN_PROGRESS` and a `Retry-After` header. Retry after that delay; you get the first request's response.
* **Sending an email** (`POST /v1/sending` to one recipient) is identified by the key itself, so even a retry after a `5xx` never sends a second copy: it returns the original send's outcome.

### Recommended keys

Use a deterministic key derived from the logical operation, so the same retry always produces the same key:

| Operation | Recommended key |
| - | - |
| Send email | `send-<emailId>-<recipientId or to>-<scheduledAt or "now">` |
| Send campaign | `campaign-send-<campaignId>` |
| Generate email | `email-gen-<projectId>-<turn or prompt hash>` |
| Add contact | `contact-<email>` |

### Anti-patterns

* **Never** use a random value such as `uuid()` or a per-attempt timestamp like `Date.now()`. A new value on each attempt defeats deduplication across retries and process restarts, which is exactly the case the key exists for.
* **Don't** hash the request body and use that as the key. The body is already part of the conflict check, and a body hash makes every distinct payload its own key rather than identifying one logical operation.

The header is honored on the endpoints where a duplicate call is costly: sending an email (`POST /v1/sending`), sending or scheduling a campaign (`POST /v1/campaigns/{id}/send` and `POST /v1/campaigns/{id}/schedule`), and the contact write endpoints (`POST /v1/contacts`, `POST /v1/contacts/bulk`, and `POST /v1/contacts/bulk-delete`).

## Brand / project scoping

An API key is scoped to your account, not to a single brand. Most resources (contacts, campaigns, segments, emails) live inside a project, so pass `projectId` on the requests that operate on them. Call `GET /v1/projects` first to discover the project IDs available to your key.

A resource that belongs to a different project than the one you reference returns `404`, the same as a resource that does not exist. The API does not reveal that a resource exists in a project you did not name.

## Events & Webhooks

Use webhooks to receive supported Migma API and contact events in your own app, queue, or automation tool:

<Card title="Events & Webhooks" icon="bolt" href="/webhooks">
  Learn how to set up event notifications
</Card>

## API endpoints

### Projects

Manage brand projects and imports:

* `GET /v1/projects` - List all projects
* `GET /v1/projects/{projectId}` - Get project details
* `POST /v1/projects/import` - Import a new brand

### Project editing

Edit project content including knowledge base, images, and logos:

* `GET /v1/projects/{projectId}/knowledge-base` - List knowledge base entries
* `POST /v1/projects/{projectId}/knowledge-base` - Add knowledge base entry
* `PUT /v1/projects/{projectId}/knowledge-base/{entryId}` - Update entry
* `DELETE /v1/projects/{projectId}/knowledge-base/{entryId}` - Remove entry
* `POST /v1/projects/{projectId}/images` - Add image (URL-only)
* `PUT /v1/projects/{projectId}/images` - Update image metadata
* `DELETE /v1/projects/{projectId}/images` - Remove image
* `PUT /v1/projects/{projectId}/logos` - Update logos

<Info>
  Project editing endpoints require the `project:write` permission.
</Info>

### Email generation

Generate AI-powered, on-brand emails with async processing:

* `POST /v1/projects/emails/generate` - Generate an email (async)
* `GET /v1/projects/emails/{conversationId}/status` - Check generation status and get `result.emails[]` with `emailId`, HTML, screenshots, and series order
* `GET /v1/emails/{emailId}` - Fetch one generated email by ID
* `POST /v1/emails/{emailId}/edit` - Prompt Migma to edit one generated email

### Email validation

Comprehensive email testing and quality analysis:

* `POST /v1/emails/validate/compatibility` - Compatibility report for major webmail, desktop, and mobile clients
* `POST /v1/emails/validate/links` - Check all links for validity
* `POST /v1/emails/validate/spelling` - AI-powered spell/grammar check
* `POST /v1/emails/validate/deliverability` - Predict inbox placement
* `POST /v1/emails/validate/all` - Run all validation checks

<Card title="Email validation API" icon="check-circle" href="/email-editor/email-preflight">
  Learn about email compatibility testing, link analysis, and deliverability prediction
</Card>

### Email previews

Generate screenshots on real devices and email clients:

* `POST /v1/emails/previews` - Create device previews
* `GET /v1/emails/previews/{previewId}` - Get preview status & results
* `GET /v1/emails/devices/supported` - List supported preview device IDs (web, desktop, mobile)

<Card title="Email preview API" icon="eye" href="/api-reference/introduction">
  See the auto-generated preview endpoint docs in the API reference
</Card>

### Contacts

Manage your contacts via API:

* `GET /v1/contacts` - List contacts
* `POST /v1/contacts` - Add a contact
* `POST /v1/contacts/bulk` - Bulk import contacts
* `POST /v1/contacts/bulk-delete` - Batch delete contacts by email
* `POST /v1/contacts/status` - Change contact status

### Campaigns

Create and manage named marketing campaigns with lifecycle tracking:

* `GET /v1/campaigns` - List campaigns
* `POST /v1/campaigns` - Create a campaign from a generated email
* `GET /v1/campaigns/{id}` - Get campaign details
* `POST /v1/campaigns/{id}/send` - Send immediately
* `POST /v1/campaigns/{id}/schedule` - Schedule for future delivery
* `POST /v1/campaigns/{id}/cancel` - Cancel a scheduled campaign
* `POST /v1/campaigns/{id}/archive` - Archive a campaign
* `POST /v1/campaigns/{id}/unarchive` - Restore an archived campaign
* `GET /v1/campaigns/{id}/stats` - Engagement stats
* `GET /v1/campaigns/{id}/logs` - Per-recipient delivery logs

### Exports

Export generated emails to files or platforms:

* `GET /v1/export/html/{conversationId}` - Export as production HTML
* `GET /v1/export/png/{conversationId}` - Export as PNG
* `GET /v1/export/pdf/{conversationId}` - Export as PDF
* `GET /v1/export/klaviyo/{conversationId}` - Export for Klaviyo
* `GET /v1/export/mailchimp/{conversationId}` - Export for Mailchimp
* `POST /v1/export/hubspot` - Export for HubSpot
* `GET /v1/export/status/{conversationId}` - Poll export status

## Error handling

Failed requests return the matching [HTTP status code](#http-status-codes) with this body:

```json theme={null}
{
  "success": false,
  "error": "Insufficient permissions"
}
```

The response does not include a separate machine-readable `code` field. Branch on the **HTTP status code** for programmatic handling, and treat `error` as a human-readable message for logging and display. For example, a missing scope returns HTTP `403` with `error: "Insufficient permissions"`.

## Environments

Use different API keys for different environments:

### Production

```text theme={null}
Base URL: https://api.migma.ai
API Key: sk_live_...
```

### Development/Testing

```text theme={null}
Base URL: https://api.migma.ai
API Key: sk_test_...
```

<Info>
  Separate keys help organize integrations. Keys belonging to the same account
  share its request budgets; a different key does not provide a separate quota.
</Info>

## SDKs & libraries

### Node.js / TypeScript (available now)

<CodeGroup>
  ```bash npm theme={null}
  npm install migma
  ```

  ```bash yarn theme={null}
  yarn add migma
  ```

  ```bash pnpm theme={null}
  pnpm add migma
  ```
</CodeGroup>

```typescript theme={null}
import Migma from 'migma';

const migma = new Migma(process.env.MIGMA_API_KEY);

const email = await migma.emails.generateAndWait({
  projectId: 'proj_123',
  prompt: 'Create a welcome email for new subscribers',
  languages: ['en']
});

const selectedEmail = email.data.result.emails[0];
console.log(selectedEmail.emailId);
console.log(selectedEmail.html);
```

<Card title="SDK Documentation" icon="book" href="/sdk">
  Full SDK guide — configuration, error handling, polling helpers, and all 14 resources
</Card>

### CLI (available now)

<CodeGroup>
  ```bash npm theme={null}
  npm install -g @migma/cli
  ```

  ```bash yarn theme={null}
  yarn global add @migma/cli
  ```
</CodeGroup>

```bash theme={null}
migma login
migma generate "Create a welcome email" --wait
migma validate all --conversation conv_123
migma send --to user@example.com --email email_123
```

<Card title="CLI Documentation" icon="terminal" href="/cli">
  Full CLI guide — all commands, workflows, and configuration
</Card>

## Need help?

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Get started in under 5 minutes
  </Card>

  <Card title="Events & Webhooks" icon="bolt" href="/webhooks">
    Set up event notifications
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    Learn about API keys and security
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Connect with developers and get support
  </Card>
</CardGroup>


# Add Image
Source: https://docs.migma.ai/api-reference/project-editing/add-image

/api-reference/openapi.json post /v1/projects/{projectId}/images
Add an image to a project by URL. Requires project:write permission.



# Add Knowledge Base Entry
Source: https://docs.migma.ai/api-reference/project-editing/add-knowledge-base-entry

/api-reference/openapi.json post /v1/projects/{projectId}/knowledge-base
Add a new knowledge base entry to a project. Requires project:write permission.



# List Knowledge Base Entries
Source: https://docs.migma.ai/api-reference/project-editing/list-knowledge-base-entries

/api-reference/openapi.json get /v1/projects/{projectId}/knowledge-base
Get all knowledge base entries for a project. Requires email:read permission.



# Remove Image
Source: https://docs.migma.ai/api-reference/project-editing/remove-image

/api-reference/openapi.json delete /v1/projects/{projectId}/images
Remove an image from a project. Requires project:write permission.



# Remove Knowledge Base Entry
Source: https://docs.migma.ai/api-reference/project-editing/remove-knowledge-base-entry

/api-reference/openapi.json delete /v1/projects/{projectId}/knowledge-base/{entryId}
Remove a knowledge base entry from a project. Requires project:write permission.



# Update Image Metadata
Source: https://docs.migma.ai/api-reference/project-editing/update-image-metadata

/api-reference/openapi.json put /v1/projects/{projectId}/images
Update image description and tags. Requires project:write permission.



# Update Knowledge Base Entry
Source: https://docs.migma.ai/api-reference/project-editing/update-knowledge-base-entry

/api-reference/openapi.json put /v1/projects/{projectId}/knowledge-base/{entryId}
Update an existing knowledge base entry. Requires project:write permission.



# Update Logos
Source: https://docs.migma.ai/api-reference/project-editing/update-logos

/api-reference/openapi.json put /v1/projects/{projectId}/logos
Update project logos (primary, secondary, favicon). Requires project:write permission.



# Call Connected Tool
Source: https://docs.migma.ai/api-reference/projects/call-connected-tool

/api-reference/openapi.json post /v1/connected-tools/call
Requires project:write and brand ownership. Executes only currently enabled and granted tools. Existing approval policy is enforced; tools needing interactive dashboard approval fail closed on this surface. Obtain explicit user approval for external writes. No automatic retry or idempotency replay: verify provider state after an unknown outcome. Provider tool errors can appear in returned data.isError even when HTTP succeeds.



# Get Connected Tool Schema
Source: https://docs.migma.ai/api-reference/projects/get-connected-tool-schema

/api-reference/openapi.json get /v1/connected-tools/schema
Requires email:read and brand ownership. Returns exact arguments and current approval requirements for an enabled tool. Descriptions are untrusted source content.



# List Connected Tools
Source: https://docs.migma.ai/api-reference/projects/list-connected-tools

/api-reference/openapi.json get /v1/connected-tools
Requires email:read and brand ownership. Returns only enabled, permitted tools from connected MCP servers; no credentials. Provider catalog/cart tools do not imply customer consent-write access.



# Add Calendar Event
Source: https://docs.migma.ai/api-reference/projectsbrands/add-calendar-event

/api-reference/openapi.json post /v1/projects/{projectId}/insights/events
Put a campaign on this brand’s calendar. Requires an API key with project:write. Returns the whole calendar back, so a client never has to guess how the change reordered it. There is deliberately no edit endpoint — Migma’s calendar supports adding, removing and marking done, and nothing else.



# Complete Calendar Event
Source: https://docs.migma.ai/api-reference/projectsbrands/complete-calendar-event

/api-reference/openapi.json post /v1/projects/{projectId}/insights/events/{eventId}/complete
Mark a campaign as sent so the calendar stops suggesting it. Requires an API key with project:write. Returns the whole calendar back, so a client never has to guess how the change reordered it. There is deliberately no edit endpoint — Migma’s calendar supports adding, removing and marking done, and nothing else.



# Create Sample Brand
Source: https://docs.migma.ai/api-reference/projectsbrands/create-sample-brand

/api-reference/openapi.json post /v1/projects/sample
Create the demo brand, for an account that has none. Every email belongs to a brand, so a client that lets someone skip brand import still needs one to convert into. Idempotent: an account that already has the sample brand gets it back rather than a second copy. Requires an API key with project:write.



# Get Import Status
Source: https://docs.migma.ai/api-reference/projectsbrands/get-import-status

/api-reference/openapi.json get /v1/projects/import/{projectId}/status
Check the status of a project import.



# Get Project Details
Source: https://docs.migma.ai/api-reference/projectsbrands/get-project-details

/api-reference/openapi.json get /v1/projects/{projectId}
Get complete project details by ID, including branding information, colors, typography, and all project data.



# Get Project Field Catalog
Source: https://docs.migma.ai/api-reference/projectsbrands/get-project-field-catalog

/api-reference/openapi.json get /v1/projects/{projectId}/field-catalog
Returns subscriber field metadata for the project: which fields exist, how often each is populated (fillRate), example values, and whether the field is auto-filled at send time. Powers variable pickers, persona prefill, and template-coverage UIs. Optionally scope the result to a specific segment or tag.



# Import Project
Source: https://docs.migma.ai/api-reference/projectsbrands/import-project

/api-reference/openapi.json post /v1/projects/import
Import a brand project from one or more website URLs. Optionally include logo URLs to skip AI logo extraction. Requires API key with project:write.



# List Brand Suggestions
Source: https://docs.migma.ai/api-reference/projectsbrands/list-brand-suggestions

/api-reference/openapi.json get /v1/projects/{projectId}/insights
What this brand should send next — the same Marketing Calendar rows the dashboard offers as starting points, each carrying the `prompt` that produced it so a suggestion is one call away from a generated email. Never blocks: a stale or missing calendar queues a refresh in the background and returns what exists now, which is legitimately an empty list for a brand imported minutes ago. Requires an API key with email:read.



# List Projects
Source: https://docs.migma.ai/api-reference/projectsbrands/list-projects

/api-reference/openapi.json get /v1/projects
List brands the authenticated user can access: owned, shared with them, and workspace-wide grants. Soft-deleted brands are excluded. Pass organizationId (from GET /v1/workspaces) to scope to one workspace. Use GET /v1/projects/{projectId} for full details.



# List Workspaces
Source: https://docs.migma.ai/api-reference/projectsbrands/list-workspaces

/api-reference/openapi.json get /v1/workspaces
Workspaces the API key owner belongs to. Pass a workspace id as organizationId to GET /v1/projects to scope the brand list to it.



# Remove Calendar Event
Source: https://docs.migma.ai/api-reference/projectsbrands/remove-calendar-event

/api-reference/openapi.json delete /v1/projects/{projectId}/insights/events/{eventId}
Take a campaign off the calendar. Requires an API key with project:write. Returns the whole calendar back, so a client never has to guess how the change reordered it. There is deliberately no edit endpoint — Migma’s calendar supports adding, removing and marking done, and nothing else.



# Retry Import
Source: https://docs.migma.ai/api-reference/projectsbrands/retry-import

/api-reference/openapi.json post /v1/projects/import/{projectId}/retry
Retry a failed or stuck import for the given project. Requires API key with project:write.



# Create Segment
Source: https://docs.migma.ai/api-reference/segments/create-segment

/api-reference/openapi.json post /v1/segments
Create a new segment with optional filters. Requires API key with audience:write.



# Delete Segment
Source: https://docs.migma.ai/api-reference/segments/delete-segment

/api-reference/openapi.json delete /v1/segments/{id}
Delete a segment. Requires API key with audience:write.



# Get Segment
Source: https://docs.migma.ai/api-reference/segments/get-segment

/api-reference/openapi.json get /v1/segments/{id}
Get a segment by ID with contact count. Requires API key with audience:read.



# List Segments
Source: https://docs.migma.ai/api-reference/segments/list-segments

/api-reference/openapi.json get /v1/segments
List segments for a project. Requires API key with audience:read.



# Update Segment
Source: https://docs.migma.ai/api-reference/segments/update-segment

/api-reference/openapi.json patch /v1/segments/{id}
Update a segment. Requires API key with audience:write.



# Create Tag
Source: https://docs.migma.ai/api-reference/tags/create-tag

/api-reference/openapi.json post /v1/tags
Create a new tag. Requires API key with audience:write.



# Delete Tag
Source: https://docs.migma.ai/api-reference/tags/delete-tag

/api-reference/openapi.json delete /v1/tags/{id}
Delete a tag. Requires API key with audience:write.



# Get Tag
Source: https://docs.migma.ai/api-reference/tags/get-tag

/api-reference/openapi.json get /v1/tags/{id}
Get a tag by ID. Requires API key with audience:read.



# List Tags
Source: https://docs.migma.ai/api-reference/tags/list-tags

/api-reference/openapi.json get /v1/tags
List tags for a project. Requires API key with audience:read.



# Update Tag
Source: https://docs.migma.ai/api-reference/tags/update-tag

/api-reference/openapi.json patch /v1/tags/{id}
Update a tag. Requires API key with audience:write.



# Create Topic
Source: https://docs.migma.ai/api-reference/topics/create-topic

/api-reference/openapi.json post /v1/topics
Create a new topic. Requires API key with audience:write.



# Delete Topic
Source: https://docs.migma.ai/api-reference/topics/delete-topic

/api-reference/openapi.json delete /v1/topics/{id}
Delete a topic. Requires API key with audience:write.



# Get Topic
Source: https://docs.migma.ai/api-reference/topics/get-topic

/api-reference/openapi.json get /v1/topics/{id}
Get a topic by ID. Requires API key with audience:read.



# List Topics
Source: https://docs.migma.ai/api-reference/topics/list-topics

/api-reference/openapi.json get /v1/topics
List topics for a project. Requires API key with audience:read.



# Subscribe Contact to Topic
Source: https://docs.migma.ai/api-reference/topics/subscribe-contact-to-topic

/api-reference/openapi.json post /v1/topics/{id}/subscribe
Subscribe a contact to a topic. Requires API key with audience:write.



# Unsubscribe Contact from Topic
Source: https://docs.migma.ai/api-reference/topics/unsubscribe-contact-from-topic

/api-reference/openapi.json post /v1/topics/{id}/unsubscribe
Unsubscribe a contact from a topic. Requires API key with audience:write.



# Update Topic
Source: https://docs.migma.ai/api-reference/topics/update-topic

/api-reference/openapi.json patch /v1/topics/{id}
Update a topic. Note: defaultSubscription cannot be changed after creation. Requires API key with audience:write.



# Create Webhook
Source: https://docs.migma.ai/api-reference/webhooks/create-webhook

/api-reference/openapi.json post /v1/webhooks
Create a new webhook endpoint. Returns the webhook configuration including a secret for signature verification. The secret is only shown once. Requires API key with webhook:write.



# Delete Webhook
Source: https://docs.migma.ai/api-reference/webhooks/delete-webhook

/api-reference/openapi.json delete /v1/webhooks/{webhookId}
Delete a webhook configuration. Requires API key with webhook:write.



# Get Webhook
Source: https://docs.migma.ai/api-reference/webhooks/get-webhook

/api-reference/openapi.json get /v1/webhooks/{webhookId}
Get webhook details by ID. Requires API key with webhook:read.



# Get Webhook Deliveries
Source: https://docs.migma.ai/api-reference/webhooks/get-webhook-deliveries

/api-reference/openapi.json get /v1/webhooks/{webhookId}/deliveries
Get recent delivery attempts for a specific webhook. Requires API key with webhook:read.



# Get Webhook Stats
Source: https://docs.migma.ai/api-reference/webhooks/get-webhook-stats

/api-reference/openapi.json get /v1/webhooks/stats
Get aggregate webhook statistics including total counts and delivery metrics. Requires API key with webhook:read.



# List Event Types
Source: https://docs.migma.ai/api-reference/webhooks/list-event-types

/api-reference/openapi.json get /v1/webhooks/events
List all available webhook event types with descriptions. Requires API key with webhook:read.



# List Webhooks
Source: https://docs.migma.ai/api-reference/webhooks/list-webhooks

/api-reference/openapi.json get /v1/webhooks
List all webhooks for the authenticated user. Requires API key with webhook:read.



# Test Webhook
Source: https://docs.migma.ai/api-reference/webhooks/test-webhook

/api-reference/openapi.json post /v1/webhooks/{webhookId}/test
Send a test event to a webhook endpoint to verify it is configured correctly. Returns the HTTP status code and response time. Requires API key with webhook:write.



# Update Webhook
Source: https://docs.migma.ai/api-reference/webhooks/update-webhook

/api-reference/openapi.json patch /v1/webhooks/{webhookId}
Update a webhook configuration. Requires API key with webhook:write.



# Import Contacts from a CSV File
Source: https://docs.migma.ai/audience/csv-upload

Import contacts from a CSV file in Migma with automatic column mapping, email validation, duplicate handling, consent status, and detailed results.

## Overview

Import hundreds or thousands of contacts at once using CSV files. Migma automatically validates emails, maps columns, handles duplicates, and provides detailed import results.

<CardGroup>
  <Card title="Bulk Import" icon="file-csv">
    Upload thousands of contacts instantly
  </Card>

  <Card title="Auto-Mapping" icon="arrows-split-up-and-left">
    Smart column detection and mapping
  </Card>

  <Card title="Validation" icon="shield-check">
    Email validation and error handling
  </Card>
</CardGroup>

***

## CSV Format

### Required Column

**Email** - Required in every CSV file

```csv theme={null}
email
john@example.com
sarah@company.com
```

### Supported Standard Columns

| Column Name | Description | Example |
| - | - | - |
| `email` | Email address (required) | [john@example.com](mailto:john@example.com) |
| `firstName` or `first_name` | First name | John |
| `lastName` or `last_name` | Last name | Doe |
| `name` | Full name | John Doe |
| `language` | Preferred language (ISO 639-1) | en, es, fr |
| `country` | Country (ISO 3166-1 alpha-2) | US, GB, CA |
| `status` | Subscription status | subscribed, unsubscribed |

### Custom Fields

Any column not matching standard names becomes a custom field automatically.

**Example CSV:**

```csv theme={null}
email,firstName,lastName,company,jobTitle
john@example.com,John,Doe,Acme Corp,CEO
sarah@tech.com,Sarah,Smith,TechCo,CTO
```

`company` and `jobTitle` are stored as custom fields.

***

## Import Process

<Steps>
  <Step title="Navigate to Contacts">
    Go to **Contacts** page in your project
  </Step>

  <Step title="Click Import CSV">
    Click **"Import CSV"** or **"Bulk Import"** button
  </Step>

  <Step title="Upload File">
    * Drag & drop CSV file or click to browse
    * Max file size: 10MB
    * Formats: .csv, .txt
  </Step>

  <Step title="Map Columns">
    Review automatic column mapping:

    * Migma auto-detects standard columns
    * Verify email column is correctly mapped
    * Custom fields are automatically identified
    * Adjust mappings if needed
  </Step>

  <Step title="Set Options">
    **Configure import:**

    * **Default Status**: Subscribed, unsubscribed, or non-subscribed
    * **Lists**: Add every imported contact to at least one List

    Migma prepares the General Topic automatically. No Topic choice is needed during import.
  </Step>

  <Step title="Review & Import">
    * Preview shows first 5 rows
    * Total contacts to import displayed
    * Click **"Import Contacts"** to start
  </Step>

  <Step title="View Results">
    Import summary shows:

    * Successfully imported
    * ⏭️ Skipped (duplicates)
    * Failed (validation errors)
  </Step>
</Steps>

***

## Column Mapping

Migma automatically detects column names. Common variations are supported:

**Email columns** (required):

* `email`, `Email`, `EMAIL`
* `e-mail`, `e_mail`

**Name columns:**

* `firstName`, `first_name`, `First Name`
* `lastName`, `last_name`, `Last Name`
* `name`, `Name`, `fullName`

**Other standard columns:**

* `language`, `lang`, `locale`
* `country`, `countryCode`, `country_code`
* `status`, `subscriptionStatus`, `subscription_status`

**Custom fields:**
Any unrecognized column name becomes a custom field (e.g., `company`, `phone`, `userId`)

***

## Validation & Handling

### Email Validation

Emails are validated automatically:

<Check>Valid format ([user@domain.com](mailto:user@domain.com))</Check>
<Check>Valid domain</Check>
<Check>No duplicates within CSV</Check>
<Check>Not already in your contact list</Check>

**Invalid emails are skipped and shown in import results**

### Duplicate Handling

<Tabs>
  <Tab title="Within CSV">
    **If CSV contains duplicate emails:**

    * Only first occurrence is imported
    * Subsequent duplicates are skipped
    * Count shown in import results
  </Tab>

  <Tab title="Existing Contacts">
    **If email already exists in your list:**

    * Existing contact is NOT updated
    * Import skips this contact
    * Preserves existing data
    * Count shown in results
  </Tab>
</Tabs>

### Status Handling

**Default status (set in UI):**

* Applied to all contacts without status column
* Options: Subscribed, Unsubscribed, Non-subscribed

**CSV status column (optional override):**

* Include `status` column to set per-contact
* Values: `subscribed`, `unsubscribed`, `non-subscribed`, `bounced`
* Overrides UI default for that row

<Warning>
  **Unsubscribed contacts:** If CSV contains `status=unsubscribed`, they will remain unsubscribed. This prevents accidental re-subscription.
</Warning>

***

## Lists

**Add Lists during import:**

<Steps>
  <Step title="Choose Lists">
    Choose or create at least one List for all imported contacts
  </Step>

  <Step title="Example Uses">
    * Source: `CSV-Import-2024`
    * Campaign: `Q4-Newsletter`
    * Type: `Event-Attendees`
  </Step>
</Steps>

<Note>
  Imported contacts are covered by the General Topic automatically. Existing Topic opt-outs stay unchanged during import.
</Note>

***

## Import Results

After import completes, you'll see a detailed summary:

**Example result:**

```text theme={null}
Import Complete!

Successfully imported: 847 contacts
⏭️ Skipped (duplicates): 23 contacts
Failed (invalid): 5 contacts

Total processed: 875 contacts
```

**Click details to see:**

* Which emails were skipped (with reason)
* Which emails failed validation
* Error messages for failed rows

***

## CSV Examples

<Tabs>
  <Tab title="Minimal (Email Only)">
    ```csv theme={null}
    email
    john@example.com
    sarah@company.com
    mike@startup.co
    ```

    Simplest format - just email addresses
  </Tab>

  <Tab title="Standard Fields">
    ```csv theme={null}
    email,firstName,lastName,language,country
    john@example.com,John,Doe,en,US
    sarah@company.com,Sarah,Smith,en,GB
    pierre@france.fr,Pierre,Martin,fr,FR
    ```

    Common standard fields
  </Tab>

  <Tab title="With Custom Fields">
    ```csv theme={null}
    email,firstName,company,jobTitle,userId
    john@example.com,John,Acme Corp,CEO,user_123
    sarah@tech.com,Sarah,TechCo,CTO,user_456
    ```

    `company`, `jobTitle`, `userId` stored as custom fields
  </Tab>

  <Tab title="With Status">
    ```csv theme={null}
    email,firstName,status
    john@example.com,John,subscribed
    old@user.com,Old,unsubscribed
    new@lead.com,New,non-subscribed
    ```

    Per-contact subscription status
  </Tab>
</Tabs>

***

## Best Practices

<AccordionGroup>
  <Accordion title="Prepare Your CSV" icon="file-csv">
    **Before uploading:**

    * Remove test data and internal emails
    * Verify email column exists
    * Check for duplicate emails
    * Use consistent column names
    * Remove special characters from column headers
    * Use UTF-8 encoding for international characters
  </Accordion>

  <Accordion title="Tag Your Imports" icon="tags">
    **Always add tags:**

    * Import source: `Mailchimp-Export`, `EventBrite`
    * Import date: `Import-Nov-2024`
    * Campaign: `Webinar-Attendees`

    Makes it easy to find and manage imported groups
  </Accordion>

  <Accordion title="Verify Before Sending" icon="shield-check">
    **After import:**

    * Check import results for errors
    * Review a few contacts to verify data
    * Filter by import tags to see the group
    * Send test email before bulk campaign
  </Accordion>

  <Accordion title="Manage List Hygiene" icon="broom">
    **Keep lists clean:**

    * Don't import [purchased or scraped lists](/get-started/what-you-can-send) (spam risk)
    * Import only opted-in contacts with documented consent
    * Honor existing unsubscribe status
    * Remove bounced emails promptly
    * For EU/UK newsletter signups, follow [GDPR newsletter consent](/compliance/gdpr-newsletter-consent) best practices
  </Accordion>
</AccordionGroup>

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="All contacts skipped as duplicates" icon="clone">
    **Cause:** Email addresses already exist in your contact list

    **Solution:**

    * Check if contacts were previously imported
    * Use different CSV or clean existing duplicates
    * Note: Existing contacts are NOT updated during import
  </Accordion>

  <Accordion title="Email column not detected" icon="envelope">
    **Cause:** Column name not recognized as email

    **Solution:**

    * Ensure column is named `email`, `Email`, or `e-mail`
    * Manually map column during import step
    * Rename column header in CSV if needed
  </Accordion>

  <Accordion title="Many emails failed validation" icon="exclamation-triangle">
    **Cause:** Invalid email formats

    **Solution:**

    * Review failed emails in import results
    * Clean email list before importing
    * Verify emails don't have extra spaces
    * Check for proper email format ([user@domain.com](mailto:user@domain.com))
  </Accordion>

  <Accordion title="Custom fields not showing" icon="database">
    **Cause:** Column names match standard field variations

    **Solution:**

    * Use unique names for custom fields
    * Avoid names like `name`, `email`, `status`
    * Check imported contacts to see custom field data
  </Accordion>

  <Accordion title="File upload fails" icon="file-circle-xmark">
    **Cause:** File too large or wrong format

    **Solution:**

    * Max size: 10MB
    * Format: .csv or .txt
    * Try saving as CSV UTF-8 from Excel/Sheets
    * Split large files into smaller batches
  </Accordion>
</AccordionGroup>

***

## Next Steps

<CardGroup>
  <Card title="Manage Contacts" icon="users" href="/audience/manage-contacts">
    View and organize imported contacts
  </Card>

  <Card title="Send Campaign" icon="paper-plane" href="/audience/sending-emails">
    Send emails to your imported list
  </Card>

  <Card title="Preference Center" icon="sliders" href="/audience/preference-center">
    Set up subscription management
  </Card>

  <Card title="API Import" icon="code" href="/api-reference/introduction">
    Import programmatically via API
  </Card>
</CardGroup>

***

## Need Help?

<CardGroup>
  <Card title="Discord Community" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Get help with CSV imports
  </Card>

  <Card title="Support Team" icon="life-ring" href="https://migma.ai/support">
    Contact support
  </Card>

  <Card title="Sample CSV" icon="download" href="https://migma.ai/sample.csv">
    Download sample CSV file
  </Card>
</CardGroup>


# Deliverability & Validation
Source: https://docs.migma.ai/audience/deliverability

Protect deliverability by excluding risky addresses, re-validating stale contacts, and building Migma audiences from current email validation status.

## Overview

Migma validates every contact against AWS-backed email insights — flagging addresses as **valid**, **invalid**, **risky**, or **unknown** — and gives you three tools to act on those flags before they hurt your sender reputation.

| Tool | Where | What it does |
| - | - | - |
| Exclude risky addresses | Settings → Email → Deliverability | Skip risky addresses on every send |
| Daily re-validation | Automatic | Re-check contacts whose validation is older than 30 days |
| Validation status filter | Contacts → Segments | Build audiences scoped by validation flag |

<Tip>
  Open **Settings → Email → Deliverability** for the risky-address toggle and validation sweep stats.
</Tip>

***

## Exclude Risky Addresses

Risky addresses are inboxes that almost always end up bouncing or generating spam complaints — disposable services like *mailinator.com* or *tempmail.io*, and role addresses like *postmaster@*, *abuse@*, or *no-reply@*. Sending to them won't help you and tends to actively hurt your sender score.

The **Exclude risky addresses** toggle in **Settings → Email → Deliverability** filters them out at fan-out time on every campaign — they never get an envelope, and they appear in the campaign's [Skipped Recipients](/campaigns/skipped-recipients) view with reason `risky` so you can audit what was held back.

<Steps>
  <Step title="Open Settings → Email → Deliverability">
    Find the **Exclude risky addresses** card.
  </Step>

  <Step title="Toggle it on">
    The setting takes effect on the next campaign send. There's nothing to backfill — Migma re-evaluates risk at fan-out time using the most recent validation data.
  </Step>

  <Step title="Watch the Skipped tab on your next send">
    Open any new campaign's **Recipients → Skipped** view. Every risky address that was held back appears with a `risky` chip and the underlying flag (e.g. *disposable*, *role*).
  </Step>
</Steps>

<Note>
  **Default off.** Many accounts run fine without this filter — flip it on if you've seen risky addresses in your bounce logs, or if you're warming a new domain and want to play it safe.
</Note>

***

## Daily Contact Re-validation

Even a clean list goes stale. Addresses that were valid six months ago can become invalid as people leave companies, change providers, or abandon mailboxes. Migma automatically re-validates **subscribed contacts whose validation is older than 30 days**, every night.

* Runs once daily, oldest-first.
* Updates each contact's validation flag and the **last validated** timestamp shown on their profile.
* Capped per run to keep validation costs bounded; tomorrow's run continues where today's left off.
* Newly-flagged risky addresses are skipped on the next send if you have the **Exclude risky** toggle on.

You can see the rolling state — last sweep time, contacts validated this month, contacts still stale — on the **Contact validation** card in the same Deliverability settings panel.

***

## Filter Audiences by Validation Status

In the segment editor, alongside the existing **Subscription status** filter, you can now scope by **Validation status** — values are *valid*, *invalid*, *risky*, and *unknown*. Combine with engagement and tag filters to triage list quality directly from the audience UI.

<CardGroup>
  <Card title="Risk audit" icon="magnifying-glass-chart">
    **Subscribed, validation = risky.**

    Everyone you'd skip with the Exclude risky toggle. Sometimes worth reviewing manually first.
  </Card>

  <Card title="Validation backlog" icon="clock-rotate-left">
    **Validation = unknown.**

    Contacts that haven't been validated yet. Often imported in bulk before validation completed.
  </Card>

  <Card title="Clean core" icon="check-double">
    **Subscribed, validation = valid, opened in past 90 days.**

    The healthy heart of your list — best target for high-stakes sends.
  </Card>

  <Card title="Pre-purge list" icon="trash-can">
    **Validation = invalid.**

    Permanent failures. Export, review, and remove to keep your list lean.
  </Card>
</CardGroup>

The contact detail view also surfaces **Last validated** so you can see when a single address was most recently checked.

***

## How the Three Pieces Fit Together

<CardGroup>
  <Card title="Validation runs continuously" icon="rotate">
    Imports validate immediately; subscribed contacts re-validate every 30 days.
  </Card>

  <Card title="Filter shows what's there" icon="filter">
    Segment editor lets you slice by current validation flag — auditing or campaign scoping.
  </Card>

  <Card title="Toggle acts on it" icon="toggle-on">
    Exclude risky drops `risky` addresses at fan-out time. Other flags still send unless you scope your audience.
  </Card>
</CardGroup>

***

## Related

<CardGroup>
  <Card title="Skipped Recipients" icon="filter-circle-xmark" href="/campaigns/skipped-recipients">
    See exactly which contacts were filtered out, including by the risky toggle.
  </Card>

  <Card title="Suppression List" icon="ban" href="/sending-domains/suppression-list">
    The hard block list — bounces, complaints, manual additions.
  </Card>
</CardGroup>


# Engagement Segments
Source: https://docs.migma.ai/audience/engagement-segments

The segment editor in Contacts → Segments supports engagement-based filters alongside the usual tag, status, and custom-field filters.

## Overview

The segment editor in **Contacts → Segments** supports engagement-based filters alongside the usual tag, status, and custom-field filters. Pick an action — **Received**, **Opened**, or **Clicked** — and a time mode to express things like *"clicked any email in the past 14 days"* or *"never opened"*.

Engagement segments refresh automatically as new opens and clicks come in, so an audience like *"VIP non-openers"* always reflects who's quiet right now.

***

## What You Can Express

| Action | Mode | Reads as |
| - | - | - |
| Received | in past N days | "Got an email from us recently" |
| Opened | in past N days | "Engaged recently" |
| Opened | not in past N days | "Was engaged but went quiet" |
| Opened | never | "Never engaged at all" |
| Clicked | in past N days | "High-intent recently" |
| Clicked | never | "No click in their history" |

Each row has an **action**, a **mode** (in past, not in past, or never), and — for the time-bound modes — a duration in **days** or **hours**.

You can stack multiple engagement rows in the same segment. Combined with tags, status, and custom fields, you can express things like *"Tagged VIP, subscribed, opened in past 30 days, has not clicked in past 30 days"* — your high-intent-but-not-converting cohort.

Segments created from Migma's AI or API can also scope **Opened** and **Clicked** to a specific campaign. For example, you can target contacts who received a launch campaign but did not click it. Campaign-scoped filters use the campaign recipient log, so Migma only targets recorded recipients and fails clearly when the campaign activity is no longer retained.

***

## Common Recipes

<CardGroup>
  <Card title="Re-engagement" icon="wand-sparkles">
    **Subscribed, received in past 90 days, not opened in past 60 days.**

    A win-back campaign target — they're still subscribed and getting your sends, but they've stopped engaging.
  </Card>

  <Card title="VIP outreach" icon="crown">
    **Tagged VIP, opened in past 14 days.**

    Recent openers from your top tier — high-intent, ready for an offer.
  </Card>

  <Card title="Cold list" icon="snowflake">
    **Subscribed, never opened.**

    Contacts who've stayed on your list but never engaged. Good for a final last-chance email before you suppress.
  </Card>

  <Card title="Recent clickers" icon="hand-pointer">
    **Clicked in past 7 days.**

    Hot prospects across all tags — try a follow-up sequence.
  </Card>
</CardGroup>

***

## How It's Tracked

Migma updates each contact's last-received, last-opened, and last-clicked timestamps from the open and click pixels embedded in your sent campaigns. There's no separate setup — engagement segments work automatically once a campaign goes out and recipients start interacting with it.

<Note>
  Open tracking depends on the recipient's email client loading images. Some clients (Apple Mail Privacy Protection, corporate mail gateways) pre-fetch every image, which can inflate open counts. Migma filters known bot opens from analytics — see [Bot Protection](/changelog#bot-protection) — but the engagement filter uses raw timestamps so it stays inclusive. Use **Clicked** when you want a higher-confidence signal.
</Note>

***

## Limits

* Time windows accept **1–365 days** or **1–8760 hours**.
* Campaign-scoped filters are supported for **Opened** and **Clicked** while the campaign recipient log is retained.
* Segments cap at **100,000 matching contacts** for live count display — larger audiences show as `>100K` and still send normally.
* Engagement membership refreshes on each access, so a segment opened twice five minutes apart may differ if a recipient just opened an email in between.

***

## Related

<CardGroup>
  <Card title="Manage Contacts" icon="user-plus" href="/audience/manage-contacts">
    Add tags and custom fields you can combine with engagement filters.
  </Card>

  <Card title="Track Campaign Results" icon="chart-line" href="/campaigns/track-results">
    See per-campaign open and click rates that feed these segments.
  </Card>
</CardGroup>


# Manage Email Contacts in Migma
Source: https://docs.migma.ai/audience/manage-contacts

Add, import, find, filter, edit, and organize Migma contacts while maintaining subscriber status, lists, segments, custom fields, and consent.

Your contacts live in the **Audience** section. You can add people one at a time, import a spreadsheet, import from a connected integration, and organize everyone with lists, segments, and filters.

***

## Adding contacts

**One at a time:**

1. Go to **Audience** in the left sidebar
2. Click **Add Contact** then **Single Contact**
3. Enter their email address and name
4. Add any lists you want
5. Hit **Save**

<img alt="Audience Add Single Contact" title="Audience Add Single Contact" />

**Importing a list:**

1. Go to **Audience** in the left sidebar
2. Click **Add Contact** then **Bulk Import**
3. Upload your CSV file
4. Map the columns to the right fields
5. Optionally apply lists to everyone being imported
6. Hit **Import**

<img alt="Audience Bulk Import Contact" title="Audience Bulk Import Contact" />

<Tip>
  Large imports process in the background. Check **Import History** to see when it is done and if anything was skipped.
</Tip>

<Card icon="file-csv" href="/audience/csv-upload" title="CSV Upload Guide">
  Full guide with column mapping and error handling
</Card>

***

## Import contacts from a CSV file

You can import a CSV either from the dashboard or through the API. Both paths upload the file, map its columns to contact fields, and process the import as a background job — so a large file never blocks you.

### From the dashboard

<Steps>
  <Step title="Upload your CSV">
    In **Audience**, click **Add Contact** then **Bulk Import** and choose your file.
  </Step>

  <Step title="Map the columns">
    Match each CSV column to a contact field. Only **Email** is required — everything else (name, phone, country, language, custom fields) maps when a column is present.
  </Step>

  <Step title="Confirm">
    Optionally apply lists to everyone in the file, then confirm. The import runs in the background.
  </Step>
</Steps>

<Tip>
  Check **Import History** to see when the job finishes and how many contacts were created, updated, or skipped.
</Tip>

### Through the API

Upload the CSV to `POST /v1/contacts/imports` as `multipart/form-data`. The file is stored and processed in the background, so the response returns immediately with an import `id`. Poll `GET /v1/contacts/imports/{id}` for the status and counts.

The endpoint needs an API key with the `audience:write` permission (`audience:read` to poll). The `columnMap` is a JSON string mapping contact fields to your CSV header names — only `email` is required.

### From MCP or ChatGPT

Call `migma_create_contact_import` once with the full CSV text and an optional list tag. Column mapping is optional when headers look like email, first name, or last name. The tool can wait and return final counts in the same turn. Prefer this over converting CSV rows into a JSON bulk import.

See [MCP Server](/mcp-server).

```typescript Node.js SDK theme={null}
import { readFileSync } from 'node:fs';
import Migma from 'migma';

const migma = new Migma('YOUR_API_KEY');

// Upload the CSV — processed in the background.
const { data: job } = await migma.contacts.imports.create({
  file: readFileSync('./contacts.csv'),
  projectId: 'PROJECT_ID',
  columnMap: {
    email: 'Email',
    firstName: 'First Name',
    customFields: { plan: 'Plan' },
  },
  onConflict: 'upsert',
  tags: ['newsletter'],
});

// Poll until the import finishes.
const { data: status } = await migma.contacts.imports.get(job!.id);
// status.status → 'pending' | 'processing' | 'completed' | 'failed'
// status.counts → { total, created, updated, skipped, failed }
```

```bash cURL theme={null}
# Start the import
curl -X POST https://api.migma.ai/v1/contacts/imports \
  -H "Authorization: Bearer $MIGMA_API_KEY" \
  -F "file=@contacts.csv" \
  -F "projectId=PROJECT_ID" \
  -F 'columnMap={"email":"Email","firstName":"First Name"}' \
  -F "onConflict=upsert" \
  -F "tags=newsletter,launch"

# Poll for status + counts
curl https://api.migma.ai/v1/contacts/imports/IMPORT_ID \
  -H "Authorization: Bearer $MIGMA_API_KEY"
```

A completed import returns counts you can reconcile against your file:

```json theme={null}
{
  "object": "contact_import",
  "id": "IMPORT_ID",
  "status": "completed",
  "counts": { "total": 1200, "created": 1150, "updated": 40, "skipped": 8, "failed": 2 },
  "error": null,
  "created_at": "2026-07-01T06:00:00.000Z",
  "completed_at": "2026-07-01T06:00:12.000Z"
}
```

<Tip>
  Set `onConflict` to `upsert` (the default) to update contacts whose email already exists, or `skip` to leave them untouched.
</Tip>

<Card icon="code" href="/api-reference/introduction" title="Contacts API Reference">
  Full request and response schema for the import endpoints
</Card>

***

## Import from an integration

If your contacts already live in Mailchimp, Klaviyo, or HubSpot, you can import them directly instead of exporting a CSV first. Click **Add Contact** then **Import from integration**, choose the provider, and pick the audience, list, segment, or tag to bring over. The import runs in the background and shows up in **Import History** with the provider, source, consent mode, and final counts.

Imports preserve consent: by default only subscribed contacts are imported, contacts without clear marketing permission stay non-sendable, and existing unsubscribed or bounced contacts are never resubscribed. Every import also creates a source list and a matching saved segment, so the imported audience is ready to target right away.

Through the API or MCP, list sources with `GET /v1/contacts/imports/providers/{provider}/sources`, start the job with `POST /v1/contacts/imports/provider`, and poll `GET /v1/contacts/imports/{id}` for status and counts. Agents can use `migma_list_provider_import_sources` and `migma_import_contacts_from_provider`. See the [Contacts API reference](/api-reference/introduction) for request and response details.

<CardGroup>
  <Card icon="plug" href="/integrations/mailchimp" title="Mailchimp">
    Import audiences, saved segments, and tags.
  </Card>

  <Card icon="plug" href="/integrations/klaviyo" title="Klaviyo">
    Import lists and segments.
  </Card>

  <Card icon="plug" href="/integrations/hubspot" title="HubSpot">
    Import contact lists with conservative consent handling.
  </Card>
</CardGroup>

***

## Finding and filtering contacts

Use the search bar to find someone by name or email. Use the filters to narrow down by status or list.

* **Status filters:** subscribed, unsubscribed, non-subscribed, bounced
* **List filters:** pick one or more lists to show contacts that have any of them

<img alt="Audience Search Contact" />

***

## Editing a contact

Click any contact row to open their detail view. From there you can update their name, email, lists, subscription status, and any custom fields you have set up.

Custom fields are great for storing extra data like company name, plan type, or account ID. You can use them in segments to build targeted groups and reference them in email templates as dynamic variables.

<img alt="Audience Edit Single Contact" title="Audience Edit Single Contact" />

***

## Bulk actions

Select multiple contacts using the checkboxes, then use the bulk action bar to update them all at once.

You can bulk update status, add or remove lists, change country or language, and update custom fields. You can also bulk delete contacts permanently.

<img alt="Audience Bulk Edit" title="Audience Bulk Edit" />

<Tip>
  Use **Select all matching** to apply changes to every contact that matches your current filters, not just the ones visible on screen.
</Tip>

<Warning>
  Deleting contacts is permanent and cannot be undone.
</Warning>

***

## What do you want to do next?

<CardGroup>
  <Card icon="users" href="/audience/manage-tags-and-segments" title="Lists and segments">
    Group your contacts to target the right people.
  </Card>

  <Card icon="file-csv" href="/audience/csv-upload" title="CSV upload">
    Full guide to importing contacts from a spreadsheet.
  </Card>

  <Card icon="rocket" href="/campaigns/send-campaign" title="Send a campaign">
    Send an email to your contacts.
  </Card>

  <Card icon="sliders" href="/audience/preference-center" title="Preference center">
    Let subscribers choose what they hear from you.
  </Card>
</CardGroup>


# Lists and Segments
Source: https://docs.migma.ai/audience/manage-tags-and-segments

Before you send a campaign, decide who should receive it. Lists and segments are the two main ways to group contacts in Migma.

Before you send a campaign, decide who should receive it. Lists and segments are the two main ways to group contacts in Migma.

***

## Lists

A list is a fixed group you manage. Use lists for contacts from a signup source, plan, event, or manual import.

**To create a list:**

1. Go to **Audience** in the left sidebar
2. Click **Lists**
3. Click **Create List**
4. Name the list and add contacts

When you send a campaign, you can target a list directly.

<img alt="Audience Create Tag" title="Audience Create Tag" />

<Tip>
  Keep list names short and specific. Names like `Newsletter`, `VIP customers`, and `Trial users` are easier to reuse later.
</Tip>

***

## Segments

A segment is a smart group that updates automatically based on rules you set. Instead of manually tagging people, you define a filter and Migma keeps the segment up to date as contacts change.

For example: everyone who signed up in the last 30 days, or everyone in your VIP list who has not opened an email in 60 days.

**To create a segment:**

1. Go to **Audience** in the left sidebar
2. Click the **Segments** tab
3. Hit **Create Segment**
4. Give it a name
5. Set your filters or leave it open to include everyone
6. Click **Create Segment**

<img alt="Audience Create Segment" title="Audience Create Segment" />

<Tip>
  Just getting started? Create one segment that includes all your contacts. You can get more specific once you have a few campaigns under your belt.
</Tip>

***

## Describe a segment in plain words

You do not have to build filters by hand. The search box at the top of the **Create Segment** dialog also drafts segments from plain language. Type what you want and Migma turns it into filters, shows the matching contact count, and leaves the draft for you to review before you save.

It understands the same things you can build manually:

* **By attribute** — "pro plan contacts in France", "everyone whose language is Spanish"
* **By engagement** — "opened in the last thirty days", "subscribed but never clicked"
* **By example** — "contacts like [alex@acme.com](mailto:alex@acme.com)" or "subscribers similar to my best customer"
* **By value group** — "investors" when their emails end in ".vc", "everyone on a gmail address"

With **by example**, Migma looks up the contact you name and builds the segment from their *distinctive* attributes, the traits that are rare across your audience, while skipping near-universal values that would just select everyone. It never filters on identity fields like email or name, so you get a lookalike group, not a copy of one person.

With **by value group**, Migma looks at the real values in a field to spot a pattern, then writes one rule for it instead of listing every value. Ask for "investors" and it can notice that many emails end in ".vc" and build the segment as "email ends with .vc". Because it is a rule, the segment stays accurate as new matching contacts arrive. When you build filters by hand, the same power is in the field condition's operator: pick **is** or **is not** for exact values, or **starts with**, **ends with**, **contains**, and **does not contain** to match by pattern.

<Tip>
  Not sure how to phrase it? Open the dialog and use the **Try** chips under the box to prefill a starting point, then edit it. For "by example", name a real contact after "contacts like".
</Tip>

This drafting lives in the dashboard. Through the API you build the same result by setting the segment's `filters` object directly, described in the filter types below.

***

## Segment filter types

A segment can combine any of these filters. They behave the same whether you build the segment in the dashboard or through the API, where they live on the segment's `filters` object.

| Filter | What it matches |
| - | - |
| Lists | Contacts that belong to any of the chosen lists |
| Exclude lists | Contacts that do **not** belong to the chosen lists, so you can carve out groups like everyone in a region except staff |
| Status | Subscription state: subscribed, unsubscribed, non-subscribed, or bounced |
| Email validation | Whether the address checked out as valid, invalid, risky, or unknown |
| Custom fields | Any custom field you store, such as `plan` or `source`, matched against the values you choose |
| Contact fields | Built-in attributes like country, language, phone, name, or inbox provider, matched with "is" or "is not" |
| Engagement | Whether a contact received, opened, or clicked within a time window. See [Engagement Segments](/audience/engagement-segments) |

Stack as many filters as you need. A contact has to satisfy all of them to land in the segment, so each filter you add narrows the group.

***

## Lists vs segments

Not sure which one to use? Here is a simple way to think about it.

| | Lists | Segments |
| - | - | - |
| **Updated by** | You, manually | Migma, automatically |
| **Best for** | Fixed groups that do not change much | Dynamic groups based on behavior or data |
| **Example** | "VIP customers", "event attendees" | Everyone who signed up this month |
| **Use in campaigns** | Yes | Yes |

In practice, most teams use both. Lists are fixed groups. Segments update as contact data and engagement change.

***

## What do you want to do next?

<CardGroup>
  <Card icon="user-plus" href="/audience/manage-contacts" title="Add contacts">
    Add contacts one by one or import a CSV list.
  </Card>

  <Card icon="rocket" href="/campaigns/send-campaign" title="Send a campaign">
    Use lists and segments to send to the right people.
  </Card>

  <Card icon="sliders" href="/audience/preference-center" title="Preference center">
    Let contacts choose what they hear from you.
  </Card>

  <Card icon="chart-bar" href="/campaigns/track-results" title="Track results">
    See how your campaigns perform after sending.
  </Card>
</CardGroup>


# Multi-Language Emails
Source: https://docs.migma.ai/audience/multi-language

Generate localized Migma emails in more than 20 languages, adapting tone, dates, currency, numbers, and cultural context beyond literal translation.

## Overview

Generate emails in multiple languages from a single prompt. Migma supports 20+ languages with localization — not just word-for-word translation, but culturally adapted content.

***

## Supported Languages

<Tabs>
  <Tab title="European">
    English, Spanish, French, German, Italian, Portuguese, Dutch, Polish, Swedish, Danish, Norwegian, Finnish
  </Tab>

  <Tab title="Asian">
    Japanese, Korean, Chinese (Simplified), Chinese (Traditional), Thai, Vietnamese, Indonesian
  </Tab>

  <Tab title="Other">
    Arabic, Russian, Hindi, Turkish, Hebrew
  </Tab>
</Tabs>

***

## How It Works

<Steps>
  <Step title="Write your prompt">
    Describe your email in your primary language (usually English).
  </Step>

  <Step title="Select languages">
    Choose target languages from the language selector before generating.
  </Step>

  <Step title="Generate">
    Migma creates a separate version for each selected language, adapted for that locale.
  </Step>

  <Step title="Review">
    Switch between language versions to review each one.
  </Step>
</Steps>

***

## Localization Features

Migma adapts more than just words:

* **Date formats** — US (12/31/2024) vs EU (31/12/2024) vs Japan (2024年12月31日)
* **Currency** — \$99.99 vs 99,99 € vs £99.99 vs ¥9,999
* **Number formatting** — 1,000.50 vs 1.000,50
* **Tone** — formal vs informal based on cultural norms (e.g., Spanish tú vs usted, French tu vs vous)
* **Name order** — Western (First Last) vs Eastern (Last First)

***

## Best Practices

* Start with English for the best results
* Have a native speaker review each version if possible
* Check that CTA buttons and links work in all versions
* Some languages are longer (German) or shorter (Chinese) — verify layout

***

## Sending Localized Campaigns

Use the subscriber `language` field to segment your audience, then send separate [campaigns](/campaigns/send-campaign) per language with the matching email version.

<CardGroup>
  <Card title="Manage Contacts" icon="users" href="/audience/manage-contacts">
    Set language on your contacts
  </Card>

  <Card title="Send a Campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Target segments by language
  </Card>
</CardGroup>


# Manage Contacts and Audiences in Migma
Source: https://docs.migma.ai/audience/overview

Manage Migma contacts, fixed lists, dynamic segments, subscription topics, preference controls, validation status, and suppression rules.

Audience is where you manage everyone who can receive email from your brand. Use it to import contacts, organize lists, build segments, manage preferences, and protect sending reputation.

Audience includes:

* **Contacts** for subscriber records, fields, status, and activity
* **Lists** for fixed groups you manage
* **Segments** for saved filters that update as contacts change
* **Topics** for subscriber-facing preference categories
* **Suppression** for addresses blocked from marketing sends

## Common use cases

* Import opted-in contacts from CSV
* Build a segment from filters or a plain-language prompt
* Target a campaign to a list or segment
* Let subscribers manage preferences
* Exclude bounced, unsubscribed, risky, or manually suppressed addresses
* Localize emails by contact language

## Best practices

**Import with consent.** Do not upload purchased, scraped, or cold outreach lists.

**Use lists for fixed groups.** Use lists for source, event, plan, or manual membership.

**Use segments for changing groups.** Use segments for engagement, validation, custom fields, and lifecycle logic.

**Review suppression before sending.** Suppression protects deliverability and compliance.

**Keep language and country fields clean.** They help Migma prepare localized campaigns.

## Next

<CardGroup>
  <Card title="Manage Contacts" icon="address-book" href="/audience/manage-contacts">
    Add, edit, import, and organize contacts.
  </Card>

  <Card title="Lists and Segments" icon="users" href="/audience/manage-tags-and-segments">
    Group contacts for campaign targeting.
  </Card>

  <Card title="CSV Upload" icon="file-csv" href="/audience/csv-upload">
    Import contacts with field mapping and validation.
  </Card>

  <Card title="Preference Center" icon="sliders" href="/audience/preference-center">
    Let subscribers choose what they receive.
  </Card>

  <Card title="Engagement Segments" icon="chart-line" href="/audience/engagement-segments">
    Group contacts by recent opens, clicks, and sends.
  </Card>

  <Card title="Deliverability" icon="shield-check" href="/audience/deliverability">
    Keep lists healthy and protect sender reputation.
  </Card>

  <Card title="Localized Emails" icon="language" href="/audience/localized-emails">
    Use contact language and country fields in campaigns.
  </Card>
</CardGroup>


# Preference Center & Unsubscribe
Source: https://docs.migma.ai/audience/preference-center

Migma's Preference Center provides a beautiful, on-brand subscription management experience that automatically inherits your brand colors, fonts, and logo.

## Overview

Migma's Preference Center provides a beautiful, on-brand subscription management experience that **automatically inherits your brand colors, fonts, and logo**. Subscribers can manage their email preferences without needing to log in, using secure token-based access.

<CardGroup>
  <Card title="Auto-Branded" icon="palette">
    Inherits your brand styling automatically
  </Card>

  <Card title="Granular Control" icon="sliders">
    Let subscribers choose what they receive
  </Card>

  <Card title="Token-Based Access" icon="key">
    Secure, no login required
  </Card>
</CardGroup>

***

## Why Preference Centers Matter

**Problem with standard unsubscribe:**

* All-or-nothing: Lose subscribers forever
* No way to reduce email frequency
* Miss opportunity to retain partial engagement

**Migma's Preference Center solution:**

* Subscribers can choose specific email types
* On-brand experience maintains trust
* Retain subscribers who just want less email
* Professional appearance

***

## Automatic Brand Inheritance

### What Gets Auto-Applied

Your Preference Center automatically inherits brand styling from your project settings:

**Brand Colors:**

* Primary color → Buttons, links, checkboxes
* Background colors → Page background, sections
* Text colors → Headings and body text
* Accent colors → Borders, highlights

**Typography:**

* Heading font → Page title, section headers
* Body font → All text content
* Font weights → Matches your email styling

**Logo:**

* Displayed at top of preference center
* Automatically sized and positioned
* Responsive on mobile devices

**Result:** Professional, branded experience that matches your emails

***

## Preference Categories

### How Preference Categories Work

**Preference categories map to tags:**

<Steps>
  <Step title="Create Preference Category">
    **Admin creates a category:**

    * Name: "Weekly Newsletter"
    * Description: "Our weekly roundup of news and tips"
    * Mapped Tag: `newsletter` tag
    * Active: Yes
    * Display Order: 1
  </Step>

  <Step title="Subscriber Sees Category">
    **On preference center page:**

    ```text theme={null}
    ☑ Weekly Newsletter
      Our weekly roundup of news and tips
    ```

    Checkbox is checked if subscriber has `newsletter` tag
  </Step>

  <Step title="Subscriber Toggles Preference">
    **Subscriber unchecks box:**

    * `newsletter` tag removed from subscriber
    * Subscriber no longer receives emails sent to newsletter tag
    * Other tags/subscriptions remain active
  </Step>

  <Step title="Granular Control">
    **Subscriber can:**

    * Turn off Weekly Newsletter
    * Keep Product Updates on
    * Keep Special Offers on
    * Only unsubscribes from specific types, not all emails
  </Step>
</Steps>

**Key concept:** Each preference category represents one tag. Toggling a preference adds/removes that tag from the subscriber.

***

## Setup Your Preference Center

<Steps>
  <Step title="Configure Brand Settings">
    **Navigate to Settings → Brand**

    **Set your brand:**

    * Upload logo
    * Choose primary color
    * Choose secondary colors
    * Select fonts
    * Add company name and address

    **These settings auto-apply** to preference center
  </Step>

  <Step title="Create Preference Categories">
    **Navigate to Preferences page (admin)**

    **Add categories:**

    1. Click "Add Category"
    2. Name: "Weekly Newsletter"
    3. Description: "Our weekly digest of news and tips"
    4. Select mapped tag: `newsletter`
    5. Active: Yes
    6. Display Order: 1 (first in list)
    7. Save

    **Create multiple categories** for different email types
  </Step>

  <Step title="Map to Existing Tags">
    **Use your existing tags:**

    * Map "Product Updates" category to `product-updates` tag
    * Map "Special Offers" category to `promotions` tag
    * Map "Blog Posts" category to `blog` tag

    **Subscribers with these tags** will see them as checked
  </Step>

  <Step title="Test Preference Center">
    **Generate test URL:**

    1. Go to Contacts
    2. Select a subscriber
    3. Click "Get Preference URL"
    4. Copy URL and open in browser

    **Verify:**

    * Brand colors applied
    * Logo displays
    * All categories shown
    * Correct checkboxes checked
    * Toggles work
  </Step>
</Steps>

***

## How Subscribers Access Preferences

### Via Unique Preference URL

**Each subscriber gets a unique URL:**

```text theme={null}
https://migma.ai/preferences/abc123def456...
```

**URL contains:**

* Permanent signed token
* No expiration
* Unique per subscriber
* No login required

**Access methods:**

**1. From email footer:**

* Include `{{preferenceUrl}}` variable in email template
* Automatically replaced with subscriber's unique URL
* Link text: "Manage your preferences" or similar

**2. From unsubscribe flow:**

* Subscriber clicks unsubscribe link
* Shown simple confirmation
* Can click to view full preferences instead

**3. From your support:**

* Generate URL in admin UI
* Share with subscriber via support ticket
* Actions: Edit subscriber → Get Preference URL

***

## Preference Center Features

### What Subscribers Can Do

**On the preference center page:**

**View current subscriptions:**

```text theme={null}
Your Email Preferences

☑ Weekly Newsletter
  Our weekly digest of news and tips

☑ Product Updates
  New features and improvements

☐ Special Offers
  Exclusive deals and promotions
```

**Toggle preferences:**

* Click checkbox to unsubscribe from that type
* Click again to resubscribe
* Changes save immediately
* Confirmation message shown

**Update profile (if enabled):**

* Name
* Email (view only, cannot change)
* Custom fields (if configured)

**Result:**

* Subscriber remains in database
* Only specified tags removed/added
* Still subscribed to other email types
* Better than complete unsubscribe

***

## Unsubscribe Functionality

### Simple Unsubscribe Page

**Unsubscribe URL format:**

```text theme={null}
https://migma.ai/unsubscribe/abc123def456...
```

**What happens:**

<Steps>
  <Step title="Click Unsubscribe Link">
    Subscriber clicks unsubscribe link in email
  </Step>

  <Step title="Simple Confirmation Page">
    **Shows:**

    ```text theme={null}
    You've been unsubscribed

    Your email address has been removed from our mailing list.

    [View Preference Center]
    ```

    **Page is intentionally simple** - confirms action quickly
  </Step>

  <Step title="Status Updated">
    **Backend updates:**

    * Subscriber status → `unsubscribed`
    * `unsubscribedAt` timestamp set
    * All tags remain (for record keeping)
    * Cannot receive marketing emails
  </Step>

  <Step title="Optional: View Preferences">
    **Link to preference center:**

    * Subscriber can click to see full preference center
    * Can resubscribe if they change their mind
    * Can manage granular preferences instead
  </Step>
</Steps>

**Note:** Unsubscribe page is not branded - simple, fast confirmation only

### Tag-Specific Unsubscribe

**Hidden feature:**

**URL format:**

```text theme={null}
https://migma.ai/unsubscribe/TOKEN?tagId=TAG_ID
```

**What happens:**

* Only removes that specific tag from subscriber
* Subscriber remains subscribed to other emails
* If last tag removed → status becomes `unsubscribed`
* Otherwise → still active with remaining tags

**Use case:**

* Unsubscribe from newsletter but keep product updates
* Bulk email sends can include tag-specific unsubscribe

***

## Technical Implementation

### Token-Based Security

**How tokens work:**

**Token generation:**

* Permanent signed token created per subscriber
* Stored as `unsubscribeToken` on subscriber record
* 32-character random string
* Unique per subscriber per project

**Token validation:**

* URL contains token in path: `/preferences/TOKEN`
* Backend verifies token exists
* Looks up subscriber by token
* No expiration - works forever

**Security:**

* Tokens are long and random (hard to guess)
* One token per subscriber (not per email send)
* No sensitive data in token
* HTTPS required for security

### Fast URL Generation

**Two methods for generating preference URLs:**

**Method 1: Standard (with DB lookup)**

```typescript theme={null}
// Looks up subscriber, returns full URL
GET /api/subscribers/:id/preference-url
```

**Method 2: Bulk (no DB lookup)**

```typescript theme={null}
// Generates URLs for many subscribers at once
// No DB queries - uses existing token
POST /api/preferences/bulk-urls
{
  subscribers: [
    { email, unsubscribeToken },
    ...
  ]
}
```

**Use bulk method** when sending to many subscribers - much faster

***

## Available Endpoints

### Admin Endpoints (Auth Required)

**Preference Category Management:**

```text theme={null}
GET    /api/preferences/categories           List all categories
POST   /api/preferences/categories           Create category
PUT    /api/preferences/categories/:id       Update category
DELETE /api/preferences/categories/:id       Delete category
GET    /api/preferences/categories/:id       Get one category
```

**Subscriber Preference URLs:**

```text theme={null}
GET    /api/subscribers/:id/preference-url   Get preference URL for one subscriber
POST   /api/preferences/bulk-urls            Generate URLs for many subscribers
```

### Public Endpoints (No Auth)

**Subscriber Preference Management:**

```text theme={null}
GET    /api/preferences/public/:token        Get subscriber preferences by token
PUT    /api/preferences/public/:token        Update subscriber preferences
GET    /api/preferences/unsubscribe/:token   Unsubscribe (with optional ?tagId=)
```

***

## Compliance Features

### CAN-SPAM Compliance

**What Migma provides:**

<Check>**Unsubscribe link** - Unique per subscriber, works immediately</Check>
<Check>**Physical address** - Added to emails from brand settings</Check>
<Check>**Instant processing** - Unsubscribes process immediately</Check>
<Check>**30-day link validity** - Links never expire (exceeds requirement)</Check>
<Check>**No login required** - Token-based access</Check>

**Your responsibilities:**

* Provide valid physical address in brand settings
* Include unsubscribe link in every marketing email
* Use `{{unsubscribeUrl}}` or `{{preferenceUrl}}` variables
* Process unsubscribes (Migma does this automatically)

### GDPR Considerations

**What Migma tracks:**

* Subscription date (`createdAt`)
* Unsubscribe date (`unsubscribedAt`)
* Current subscription status
* Preference category selections (via tags)

**Data export:**

* Admins can export subscriber data via CSV
* Includes all fields, tags, custom fields
* Available via Contacts page export

**Data deletion:**

* Admins can delete subscribers manually
* Permanent deletion from database
* Use with caution - no recovery

**What's NOT implemented:**

* Self-service data download (subscriber-initiated)
* Self-service account deletion (subscriber-initiated)
* Consent history logging
* GDPR-specific compliance tools

**Recommendation:** For full GDPR compliance, you may need additional processes beyond Migma's built-in features.

***

## Best Practices

<AccordionGroup>
  <Accordion title="Create Meaningful Categories" icon="tags">
    **Good category names:**

    ```text theme={null}
    Weekly Newsletter
    Product Updates
    Special Offers
    Event Invitations
    Blog Posts
    ```

    **Poor category names:**

    ```text theme={null}
    Emails
    Updates
    Tag 1
    Newsletter Tag
    ```

    **Why:**

    * Clear names help subscribers understand what they're (un)subscribing from
    * Descriptive helps reduce confusion
    * Professional appearance
  </Accordion>

  <Accordion title="Add Helpful Descriptions" icon="message">
    **Good descriptions:**

    ```text theme={null}
    Weekly Newsletter
    → Our weekly roundup of the latest news, tips, and insights

    Product Updates
    → Announcements about new features and improvements

    Special Offers
    → Exclusive deals and promotions (1-2 per month)
    ```

    **Why:**

    * Helps subscribers make informed choices
    * Sets expectations (frequency, content type)
    * Reduces unwanted unsubscribes
  </Accordion>

  <Accordion title="Use Display Order Wisely" icon="arrow-down-1-9">
    **Recommended order:**

    **Most important first:**

    1. Product/service updates (critical)
    2. Newsletter (regular content)
    3. Educational content
    4. Promotional offers (least critical)

    **Why:**

    * Most engaged subscribers see important options first
    * De-emphasize promotional content
    * Increase retention of key subscriptions
  </Accordion>

  <Accordion title="Test Regularly" icon="vial">
    **Monthly testing checklist:**

    **Test unsubscribe:**

    * ☑ Send test email
    * ☑ Click unsubscribe link
    * ☑ Verify confirmation page loads
    * ☑ Check subscriber status updated
    * ☑ Verify no longer in tag

    **Test preference center:**

    * ☑ Generate preference URL
    * ☑ Open in browser
    * ☑ Verify brand applied correctly
    * ☑ Toggle preferences
    * ☑ Verify changes saved
    * ☑ Check tags updated

    **Why:**

    * Catch broken links
    * Verify branding still applies
    * Ensure compliance
    * Maintain trust
  </Accordion>

  <Accordion title="Include in Every Email" icon="envelope">
    **Required in all marketing emails:**

    **Email footer should include:**

    ```html theme={null}
    <a href="{{preferenceUrl}}">Manage Preferences</a>
    |
    <a href="{{unsubscribeUrl}}">Unsubscribe</a>
    ```

    **Or simpler:**

    ```html theme={null}
    <a href="{{unsubscribeUrl}}">Unsubscribe</a>
    ```

    **Why:**

    * Legal requirement (CAN-SPAM)
    * Reduces spam complaints
    * Maintains trust
    * Better deliverability
  </Accordion>
</AccordionGroup>

***

## Common Use Cases

### Newsletter with Multiple Topics

**Setup:**

```text theme={null}
Preference Categories:
☑ Weekly Digest
  Our main newsletter (every Monday)

☑ Breaking News
  Important updates as they happen

☑ Community Spotlights
  Featured member stories (monthly)
```

**Result:** Subscribers can get digest without breaking news alerts

### SaaS Product Communications

**Setup:**

```text theme={null}
Preference Categories:
☑ Product Updates
  New features and improvements

☑ Educational Content
  Tips, tutorials, and best practices

☑ System Notifications
  Important alerts about your account

☑ Company News
  Blog posts and announcements
```

**Result:** Users can get product updates without marketing content

### E-commerce Store

**Setup:**

```text theme={null}
Preference Categories:
☑ New Arrivals
  Latest products added to store

☑ Sales & Promotions
  Exclusive deals and discounts

☑ Back in Stock
  Notifications when items return

☑ Order Updates
  Shipping and delivery notifications
```

**Result:** Customers can control promotional emails while keeping order updates

***

## Limitations

### Current Limitations

**Features NOT currently available:**

<Warning>**Feedback collection** - Cannot ask why subscriber is unsubscribing</Warning>
<Warning>**GDPR self-service** - No subscriber-initiated data download or account deletion</Warning>
<Warning>**Analytics** - No tracking of preference changes or retention metrics</Warning>
<Warning>**One-click unsubscribe headers** - No RFC 8058 List-Unsubscribe headers</Warning>
<Warning>**Frequency preferences** - Cannot let subscribers choose email frequency</Warning>
<Warning>**Multi-brand** - Single brand per project only</Warning>

**What works:**

* Granular preference categories
* On-brand design with auto-inheritance
* Token-based secure access
* Instant unsubscribe
* Tag-specific unsubscribe
* No login required
* Mobile responsive

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="Preference URL Not Working" icon="link-slash">
    **Problem:** Link returns error or doesn't load

    **Check:**

    1. Token is valid (32 characters)
    2. Subscriber exists in database
    3. URL format correct: `/preferences/TOKEN`
    4. HTTPS (not HTTP)

    **Test:**

    * Generate new URL from admin UI
    * Try in different browser
    * Check subscriber still exists
  </Accordion>

  <Accordion title="Brand Not Applied" icon="palette">
    **Problem:** Preference center uses default colors

    **Check:**

    1. Brand settings configured (Settings → Brand)
    2. Logo uploaded
    3. Primary color selected
    4. Fonts chosen
    5. Clear browser cache

    **Note:** Brand changes take effect immediately
  </Accordion>

  <Accordion title="Preferences Not Saving" icon="floppy-disk">
    **Problem:** Subscriber toggles preference but change doesn't stick

    **Check:**

    1. Browser JavaScript enabled
    2. No console errors (F12 developer tools)
    3. Subscriber record exists
    4. Tag exists in project
    5. Preference category is active

    **Debug:**

    * Check network tab for API errors
    * Verify tag mapping correct
    * Test with different subscriber
  </Accordion>

  <Accordion title="Category Not Showing" icon="eye-slash">
    **Problem:** Preference category doesn't appear on preference center

    **Check:**

    1. Category is **Active** (not inactive)
    2. Mapped tag exists
    3. Display order set
    4. Category saved properly

    **Fix:**

    * Edit category, verify all fields
    * Toggle Active off and on
    * Save again
    * Refresh preference center page
  </Accordion>

  <Accordion title="Unsubscribe Not Working" icon="ban">
    **Problem:** Click unsubscribe but still receiving emails

    **Check:**

    1. Unsubscribe link clicked successfully
    2. Subscriber status changed to `unsubscribed`
    3. Check send logs - should show "skipped"
    4. Not using different email address

    **Remember:**

    * Unsubscribe is immediate
    * Emails in flight may still deliver
    * Check correct subscriber record
  </Accordion>
</AccordionGroup>

***

## Next Steps

<CardGroup>
  <Card title="Manage Contacts" icon="users" href="/audience/manage-contacts">
    Add and organize subscribers
  </Card>

  <Card title="Sending Emails" icon="paper-plane" href="/audience/sending-emails">
    Send to your audience
  </Card>

  <Card title="CSV Upload" icon="file-csv" href="/audience/csv-upload">
    Bulk import subscribers
  </Card>

  <Card title="Audience Overview" icon="chart-line" href="/audience/overview">
    Subscriber management overview
  </Card>
</CardGroup>

***

## Need Help?

<CardGroup>
  <Card title="Join Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Get help with compliance
  </Card>

  <Card title="Contact Support" icon="life-ring" href="https://migma.ai/support">
    Preference center questions
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Subscriber API documentation
  </Card>
</CardGroup>


# Send Emails to a Migma Audience
Source: https://docs.migma.ai/audience/sending-emails

Send emails to your audience using campaigns. Campaigns let you select a segment or list as recipients, configure sender settings, and track results.

## Overview

Send emails to your audience using [campaigns](/campaigns/overview). Campaigns let you select a segment or list as recipients, configure sender settings, and track results.

<Frame>
  <img alt="Email logs and tracking" />
</Frame>

<Info>
  Email sending in Migma is done through the **Campaigns** section, not from the Contacts page directly.
</Info>

***

## Quick Start

<Steps>
  <Step title="Create your email">
    Use Migma's AI tools to [create an email](/creating-emails/overview) in the chat editor.
  </Step>

  <Step title="Set up your audience">
    Add contacts, organize with [lists](/audience/overview), and create [segments](/audience/overview) from the Audience page.
  </Step>

  <Step title="Create a campaign">
    Go to **Campaigns** and [create a campaign](/campaigns/send-campaign). Select your email, choose recipients (segment or list), configure sender settings, and send or schedule.
  </Step>
</Steps>

***

## Prerequisites

<Warning>
  **Email service provider required** — configure an ESP before sending.
</Warning>

* Connected email provider (Migma, Amazon SES, Resend, SendGrid, or Mailgun)
* Verified sending domain
* At least one contact with `subscribed` status

<Card title="Setup Email Provider" icon="server" href="/integrations/email-service-providers">
  Connect and configure your email service provider
</Card>

***

## Unsubscribe & Compliance

Migma handles compliance automatically:

* Unsubscribe links are added to every marketing email
* Clicking unsubscribe updates the contact's status immediately
* Unsubscribed contacts cannot receive marketing emails
* [Preference center](/audience/preference-center) lets subscribers manage their topic preferences

***

## Send via API

Send emails programmatically via the [SDK](/sdk), [CLI](/cli), or [API](/api-reference/introduction).

The `from` address determines your **sending domain** — it must be a [verified domain](/sending-domains/overview). The optional `providerType` field selects which email service provider delivers the message. It defaults to `migma` (built-in sending).

For generated emails, use the `emailId` returned by generation status or shown in **Publish → Send via API**. `conversationId` identifies the whole chat thread; it works for single-email conversations, but multi-slot emails and series need `emailId` so the API knows which email to send.

```typescript theme={null}
await migma.sending.send({
  recipientType: 'email',
  recipientEmail: 'sarah@example.com',
  from: 'hello@yourcompany.migma.email',
  fromName: 'Your Company',
  subject: 'Welcome!',
  emailId: 'email_123'
});
```

<Tabs>
  <Tab title="Migma (default)">
    No `providerType` needed — Migma sends by default. Use a [verified sending domain](/sending-domains/overview) (managed or custom).

    ```typescript theme={null}
    await migma.sending.send({
      recipientType: 'email',
      recipientEmail: 'sarah@example.com',
      from: 'hello@yourcompany.migma.email',
      fromName: 'Your Company',
      subject: 'Welcome!',
      template: source,
      projectId: 'proj_123'
    });
    ```
  </Tab>

  <Tab title="Amazon SES">
    Requires [Amazon SES connected](/integrations/amazon-ses) in Settings → Integrations.

    ```typescript theme={null}
    await migma.sending.send({
      recipientType: 'email',
      recipientEmail: 'sarah@example.com',
      from: 'hello@yourdomain.com',
      fromName: 'Your Company',
      subject: 'Welcome!',
      template: source,
      projectId: 'proj_123',
      providerType: 'ses'
    });
    ```
  </Tab>

  <Tab title="Resend">
    Requires [Resend connected](/integrations/resend) in Settings → Integrations.

    ```typescript theme={null}
    await migma.sending.send({
      recipientType: 'email',
      recipientEmail: 'sarah@example.com',
      from: 'hello@yourdomain.com',
      fromName: 'Your Company',
      subject: 'Welcome!',
      template: source,
      projectId: 'proj_123',
      providerType: 'resend'
    });
    ```
  </Tab>

  <Tab title="SendGrid">
    Requires [SendGrid connected](/integrations/sendgrid) in Settings → Integrations.

    ```typescript theme={null}
    await migma.sending.send({
      recipientType: 'email',
      recipientEmail: 'sarah@example.com',
      from: 'hello@yourdomain.com',
      fromName: 'Your Company',
      subject: 'Welcome!',
      template: source,
      projectId: 'proj_123',
      providerType: 'sendgrid'
    });
    ```
  </Tab>

  <Tab title="Mailgun">
    Requires Mailgun connected in Settings → Integrations.

    ```typescript theme={null}
    await migma.sending.send({
      recipientType: 'email',
      recipientEmail: 'sarah@example.com',
      from: 'hello@yourdomain.com',
      fromName: 'Your Company',
      subject: 'Welcome!',
      template: source,
      projectId: 'proj_123',
      providerType: 'mailgun'
    });
    ```
  </Tab>
</Tabs>

<CardGroup>
  <Card title="Sending Domains" icon="globe" href="/sending-domains/overview">
    Set up and verify a sending domain
  </Card>

  <Card title="Email Service Providers" icon="server" href="/integrations/email-service-providers">
    Connect an external ESP
  </Card>
</CardGroup>

***

## Transactional vs Marketing

Migma automatically infers the email type from how you send:

| Send type | Default behavior | Example |
| - | - | - |
| **Single recipient** (`recipientType: 'email'`) | Transactional | Order confirmations, password resets |
| **Batch** (`recipientType: 'audience'`, `'tag'`) | Marketing | Newsletters, promotions |

**Transactional** emails bypass subscription status, skip topic filtering, and omit List-Unsubscribe headers. Bounced addresses are always excluded.

This means single sends just work — no extra flags needed:

```typescript theme={null}
// Automatically treated as transactional — no flag needed
await migma.sending.send({
  recipientType: 'email',
  recipientEmail: 'customer@example.com',
  from: 'noreply@yourcompany.migma.email',
  fromName: 'Your Company',
  subject: 'Your order has shipped',
  template: source,
  projectId: 'proj_123'
});
```

For edge cases, use the `transactional` flag to override the default:

```typescript theme={null}
// Batch transactional: "Your subscription renews tomorrow" to all active users
await migma.sending.send({
  recipientType: 'tag',
  recipientId: 'tag_active_subscribers',
  from: 'noreply@yourcompany.migma.email',
  fromName: 'Your Company',
  subject: 'Your subscription renews tomorrow',
  template: source,
  projectId: 'proj_123',
  transactional: true
});
```

<Warning>
  Only use `transactional: true` on batch sends for emails the recipient expects regardless of subscription status (renewal reminders, security alerts). Using it for promotional content violates CAN-SPAM and GDPR.
</Warning>

***

## Next Steps

<CardGroup>
  <Card title="Send a Campaign" icon="rocket" href="/campaigns/send-campaign">
    Step-by-step campaign guide
  </Card>

  <Card title="Track Results" icon="chart-line" href="/campaigns/track-results">
    Monitor campaign performance
  </Card>

  <Card title="Manage Contacts" icon="users" href="/audience/manage-contacts">
    Organize your subscriber list
  </Card>

  <Card title="Setup ESP" icon="server" href="/integrations/email-service-providers">
    Connect email service provider
  </Card>
</CardGroup>


# Authenticate Migma API Requests
Source: https://docs.migma.ai/authentication

Authenticate Migma API requests with a Bearer API key, store credentials server-side, choose the minimum required scopes, and rotate exposed keys.

## Start here

1. Hosted MCP: add `https://migma.ai/mcp` and approve in the browser. See [MCP Server](/mcp-server). IT reviewers: [MCP for IT admins](/security/mcp).
2. CLI: run `migma login`. Same browser sign-in; the key is stored locally.
3. Direct agents without a working OAuth callback: fetch `https://api.migma.ai/auth.md` and approve the claim code. They must be able to call the API, poll, and securely store the returned credential. See [Agent registration](/agent-registration).
4. CI and servers: set `MIGMA_API_KEY`. Create a Settings key only for this case.

## API Keys

Migma.ai uses API keys to authenticate requests. Browser OAuth and claim-code both mint a key for you. Keep keys out of client-side code and git.

## Creating a CI API Key

Use this only for CI, cron, or server automation. Agents and the CLI should not start here.

<Steps>
  <Step title="Navigate to Settings">
    Log in to [migma.ai](https://migma.ai) and go to **Settings → Developers → API Keys**
  </Step>

  <Step title="Create New Key">
    Click **Create API Key** in the API Keys tab
  </Step>

  <Step title="Configure Permissions">
    Give your key a name and select the permissions it needs
  </Step>

  <Step title="Save Securely">
    Copy the key immediately - it won't be shown again!
  </Step>
</Steps>

<Warning>
  API keys are shown only once at creation. Store them securely in a password manager or environment variables.
</Warning>

## Using Your API Key

Include your API key in the `Authorization` header of every request:

```bash theme={null}
Authorization: Bearer YOUR_API_KEY
```

### Example Request

```typescript Node.js SDK theme={null}
import Migma from 'migma';

// The SDK handles the Authorization header automatically
const migma = new Migma('YOUR_MIGMA_API_KEY');
const { data, error } = await migma.projects.list();
```

```bash cURL theme={null}
curl https://api.migma.ai/v1/projects \
  -H "Authorization: Bearer YOUR_MIGMA_API_KEY"
```

```javascript JavaScript theme={null}
const response = await fetch('https://api.migma.ai/v1/projects', {
  headers: {
    'Authorization': 'Bearer YOUR_MIGMA_API_KEY'
  }
});
```

```python Python theme={null}
import requests

headers = {
    'Authorization': 'Bearer YOUR_MIGMA_API_KEY'
}

response = requests.get(
    'https://api.migma.ai/v1/projects',
    headers=headers
)
```

## API Key Permissions

When creating an API key, you can grant specific permissions to limit what the key can access.

### Audience Permissions

| Permission | Description |
| - | - |
| `audience:read` | View subscribers, tags, and audience segments |
| `audience:write` | Add, update subscribers, manage tags, create segments |
| `email:read` | View email templates and sending history |
| `email:write` | Create and edit generated emails |
| `email:send` | Send test and live emails |
| `email:validate` | Test email compatibility, check links, and analyze deliverability |
| `email:preview` | Generate email previews across multiple devices and email clients |
| `domain:read` | View sending domains, verification and purchase status, and custom DNS on domains bought in Migma |
| `domain:write` | Add, verify, update, and remove sending domains; buy a domain (Stripe checkout the account owner opens); manage custom DNS on domains bought in Migma |
| `billing:read` | View plan and credits |
| `billing:write` | Create Stripe checkout or billing portal links the account owner opens and approves |
| `campaign:read` | View campaigns, stats, and delivery logs |
| `campaign:write` | Create, send, schedule, cancel, archive, and unarchive campaigns |
| `project:write` | Import projects and manage project resources |
| `webhook:read` | List and view webhook configurations |
| `webhook:write` | Create, update, and delete webhooks for real-time notifications |

<Tip>
  Follow the principle of least privilege: only grant the permissions your application needs.
</Tip>

<Warning>
  `email:send` allows test and direct email. `campaign:write` allows campaign creation, send, and schedule. Omitting `scope` grants the full permission set — the approval page shows every permission and marks send as destructive. Pass an explicit `scope` to narrow access.
</Warning>

## Environment-Specific Keys

Use different API keys for different environments:

```bash Development theme={null}
MIGMA_API_KEY=sk_test_...
```

```bash Production theme={null}
MIGMA_API_KEY=sk_live_...
```

<Info>
  Test keys start with `sk_test_` and production keys start with `sk_live_`
</Info>

## Security best practices

* **Never hardcode keys** — use environment variables: `const migma = new Migma(process.env.MIGMA_API_KEY)`
* **Least privilege** — only grant the permissions your integration actually needs
* **Rotate periodically** — create a new key, update your app, then revoke the old one
* **Monitor usage** — check last-used dates in **Settings → Developers → API Keys** and revoke anything unexpected
* **Remote agents** — keep claim tokens and returned keys out of chat, logs, shell history, and shared remote-computer files

## Key Management

### Viewing Your Keys

Navigate to **Settings → Developers → API Keys** to see:

* Key name and ID (first 8 characters)
* Permissions granted
* Creation date
* Last used date
* Usage statistics

### Revoking a Key

If a key is compromised or no longer needed:

<Steps>
  <Step title="Find the Key">
    Go to **Settings → Developers → API Keys**
  </Step>

  <Step title="Delete">
    Click the delete icon next to the key
  </Step>

  <Step title="Confirm">
    Confirm the deletion - this action cannot be undone
  </Step>
</Steps>

<Warning>
  Revoking a key will immediately invalidate it. Any applications using that key will receive 401 Unauthorized errors.
</Warning>

## Error Responses

### 401 Unauthorized

Your API key is invalid or missing:

```json theme={null}
{
  "success": false,
  "error": "Invalid or missing API key"
}
```

**Common causes:**

* API key not included in Authorization header
* Wrong format (must be `Bearer YOUR_KEY`)
* Key has been revoked
* Using test key in production environment

### 403 Forbidden

Your API key doesn't have permission for this action:

```json theme={null}
{
  "success": false,
  "error": "Insufficient permissions"
}
```

**Solution:** Create a new key with the required permissions or update the existing key's permissions.

## Rate Limiting

API keys belonging to the same account share plan-based request budgets per
route group. Sending API requests have a separate budget sized to support your
account's recipients/second allowance. Creating or rotating a key does not
increase the budget.

Check **Settings → Developers → API Keys → API limits** for your effective
allowances. Responses that reach the request limiter include these headers
(illustrative values):

```http theme={null}
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 95
X-RateLimit-Reset: 1609459200
```

When you exceed the rate limit, you'll receive a `429 Too Many Requests` response:

```json theme={null}
{
  "success": false,
  "error": "Rate limit exceeded. Please try again later."
}
```

<Tip>
  Wait for the `Retry-After` response header (seconds), then retry with backoff.
  Keep the same API key and `Idempotency-Key` when retrying the same send.
</Tip>

See [API rate limiting](/api-reference/introduction#rate-limiting) for sending
throughput, volume quotas, route groups, and temporary `503` responses.

## Need help?

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Get started with your first API call
  </Card>

  <Card title="Node.js SDK" icon="npm" href="/sdk">
    SDK handles authentication automatically
  </Card>

  <Card title="CLI" icon="terminal" href="/cli">
    `migma login` to authenticate the CLI
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Full endpoint documentation
  </Card>
</CardGroup>


# Campaigns vs Email Series
Source: https://docs.migma.ai/campaigns/campaigns-vs-email-series

Choose a Migma campaign for one reviewed audience send, or an email series when you need a connected multi-message journey to prepare and manage.

Campaigns and email series solve different jobs. Use **Campaigns** when you are ready to send one email to an audience. Use **Email Series** when you need a connected sequence drafted and edited together.

## Quick choice

<CardGroup>
  <Card title="Use Campaigns" icon="bullhorn" href="/campaigns/overview">
    Send or schedule one approved email to a segment or tag, then track delivery and engagement.
  </Card>

  <Card title="Use Email Series" icon="layer-group" href="/creating-emails/email-series">
    Generate and refine a welcome flow, launch sequence, nurture path, or winback journey from one brief.
  </Card>
</CardGroup>

***

## Difference

| | Campaigns | Email Series |
| - | - | - |
| Main job | Deliver one email to an audience | Plan and create multiple related emails |
| Best for | Newsletters, product launches, promos, announcements | Welcome flows, onboarding, launch arcs, nurture paths |
| Where you work | **Campaigns** | **Create** and the **Visual Canvas** |
| Audience | Segment or tag chosen before send | Audience can be chosen when each email or sequence is sent |
| Timing | Send now or schedule one send time | Add per-email cadence, then send or export the sequence |
| Review | Preflight the selected email before launch | Preflight each email in the series |

***

## Common flow

<Steps>
  <Step title="Create the emails">
    Generate one email from a prompt, or create a multi-email sequence in [Email Series](/creating-emails/email-series).
  </Step>

  <Step title="Review before sending">
    Run [Email Preflight](/email-editor/email-preflight) on each email that will go out.
  </Step>

  <Step title="Send through Campaigns">
    Create a [campaign](/campaigns/send-campaign), choose the audience, configure the sender, then send or schedule.
  </Step>
</Steps>

<Info>
  For event-triggered ecommerce flows in Klaviyo, Mailchimp, HubSpot, Brevo, or another ESP, create and preflight the email in Migma, then export or sync it to that platform's automation flow.
</Info>

***

## Related

<CardGroup>
  <Card title="Send campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Launch one email to an audience.
  </Card>

  <Card title="Email series" icon="layer-group" href="/creating-emails/email-series">
    Draft and edit a connected sequence.
  </Card>

  <Card title="Visual canvas" icon="diagram-project" href="/creating-emails/visual-canvas">
    See sequences, references, and campaign planning in one workspace.
  </Card>

  <Card title="Export options" icon="arrow-up-right" href="/email-editor/export-options">
    Move Migma emails into another sending platform.
  </Card>
</CardGroup>


# Add Brand Logos to Email Inboxes
Source: https://docs.migma.ai/campaigns/inbox-icons

Add a verified brand logo or sender photo to supported inboxes using BIMI or a Google profile, helping recipients recognize your Migma campaigns.

Adding your brand logo or personal photo to emails can significantly enhance your email marketing effectiveness. Research shows that visual identifiers in the inbox improve brand recognition, increase open rates by up to 21%, and strengthen recipient trust in your communications.

***

## Why Inbox Icons Matter

Having your company logo or personal photo appear in recipients' inboxes offers several important advantages:

<CardGroup>
  <Card title="Enhanced Brand Recognition" icon="eye">
    Visual identifiers help your emails stand out in crowded inboxes, creating immediate recognition even before recipients open your messages
  </Card>

  <Card title="Higher Open Rates" icon="chart-line">
    Emails with recognizable logos or photos can increase open rates by up to 21%, significantly improving campaign performance
  </Card>

  <Card title="Improved Trust" icon="shield-check">
    Recipients feel more confident about email legitimacy when they can see a familiar logo or face, reducing concerns about potential phishing attempts
  </Card>

  <Card title="Professional Appearance" icon="star">
    A consistent visual identity across all communications presents a more polished, professional brand experience
  </Card>
</CardGroup>

***

## Setup Options

There are two primary ways to add your logo or photo to emails, varying in complexity and coverage:

<Tabs>
  <Tab title="Email Client Setup (Easy)">
    This approach lets you add icons to individual email providers by setting up profiles, with support for both company logos and personal photos/headshots.

    **Advantages:**

    * Supports both personal photos and company logos
    * No additional costs beyond basic accounts
    * Simple setup process with minimal technical skill

    **Limitations:**

    * Must set up separately for each email provider
    * Limited to supported email clients only
    * No verification or trust indicators
  </Tab>

  <Tab title="BIMI (Advanced)">
    Brand Indicators for Message Identification (BIMI) is an email specification that allows your logo to appear automatically across supporting email clients.

    **Advantages:**

    * Automatic display across all supporting clients
    * Verified mark option adds trust indicator
    * Single setup covers multiple providers

    **Limitations:**

    * Requires strict DMARC policy
    * VMC certificate costs \~\$1,500/year
    * More complex technical setup
  </Tab>
</Tabs>

***

## Gmail Setup

<Steps>
  <Step title="Log In">
    Log in to the Google/Gmail account associated with your sending address
  </Step>

  <Step title="Access Account Settings">
    Click your profile icon in the top-right corner, then click "Manage your Google Account"
  </Step>

  <Step title="Navigate to Personal Info">
    Select "Personal info" from the left menu
  </Step>

  <Step title="Update Profile Picture">
    Under "Profile," click on your profile picture and upload your logo or photo
  </Step>

  <Step title="Save Changes">
    Click "Set as profile photo"
  </Step>
</Steps>

<Note>
  Gmail displays icons in the mobile app (including push notifications) and inside opened emails on desktop, but not in the inbox list view on desktop.
</Note>

***

## Apple Mail (Branded Mail)

Apple Branded Mail lets you display your logo as an avatar in Apple Mail inboxes on supported devices (iOS, iPadOS, macOS). This increases brand recognition and trust for recipients using Apple Mail.

<Warning>
  Apple Branded Mail only works in Apple Mail on recent iOS, iPadOS, and macOS versions. Your logo will not show in other mail clients or older Apple Mail versions.
</Warning>

### Prerequisites

* Apple Business Connect account ([Sign up here](https://businessconnect.apple.com))
* DMARC configured in your DNS records (part of your email authentication setup)
* Company identification number for Apple verification

### Setup Steps

<Steps>
  <Step title="Configure DMARC">
    DMARC is an email authentication record required for Apple Branded Mail. If you've completed DNS setup for your email service provider, you may already have DMARC configured.

    You may need to update your DMARC policy to `p=quarantine;` or `p=reject;` and `pct=100`.

    **Example DMARC record:**

    ```text theme={null}
    v=DMARC1; p=quarantine; pct=100; rua=mailto:dmarcreports@example.com
    ```

    <Tip>
      If you're updating your DMARC policy, test your email deliverability first to ensure everything is working as expected.
    </Tip>
  </Step>

  <Step title="Add Company Details">
    After creating your Apple Business Connect account:

    * Enter your company address, name, and other required details
    * Select the **Branded Mail** option in the sidebar
    * Add your brand name and website
  </Step>

  <Step title="Upload Your Logo">
    Apple requires the logo to be at least **1024 x 1024 px** in `.png`, `.heif`, or `.jpeg` format.

    Upload your logo in the Branded Mail section.
  </Step>

  <Step title="Add Your Domain(s)">
    Specify the domains or email addresses where you want your logo to appear.

    <Note>
      You can register your logo for your root domain or a subdomain. If you don't set a specific logo for a subdomain, the root domain logo will automatically display for any email sent from your subdomains.
    </Note>
  </Step>

  <Step title="Verify Your Company">
    * Provide your company identification number (e.g., Federal Taxpayer ID in the US, local equivalent elsewhere)
    * Apple will prompt you to add a DNS record to verify you control your domain
    * Follow their instructions to complete this step
  </Step>

  <Step title="Apple Review">
    Apple will review your submission. This process may take up to **seven business days**.

    Once approved, you'll receive an email notification and your logo will display in Apple Mail for supported recipients.
  </Step>
</Steps>

<Info>
  This only works with commercial domains (not gmail.com, etc.) and requires properly configured DNS records.
</Info>

***

## Outlook Setup

<Steps>
  <Step title="Log In">
    Log in to your Outlook account
  </Step>

  <Step title="Access Profile">
    Click your profile icon in the top-right corner and select "My profile" or "View account"
  </Step>

  <Step title="Edit Profile">
    Click on "Edit profile"
  </Step>

  <Step title="Upload Image">
    Upload your logo or photo
  </Step>

  <Step title="Save">
    Save changes
  </Step>
</Steps>

<Note>
  Outlook primarily displays icons in the mobile app and inside opened emails on desktop.
</Note>

***

## Yahoo Mail Setup

<Steps>
  <Step title="Log In">
    Log in to your Yahoo account
  </Step>

  <Step title="Access Account">
    Click your profile icon and select "Account info"
  </Step>

  <Step title="Navigate to Personal Info">
    Navigate to "Personal info"
  </Step>

  <Step title="Update Image">
    Click on your profile image and upload your logo or photo
  </Step>

  <Step title="Save">
    Save changes
  </Step>
</Steps>

<Note>
  Yahoo Mail offers more comprehensive icon support, displaying them in both the message list and message view.
</Note>

***

## Gravatar Setup

Gravatar is used by several email clients including Thunderbird, Airmail, and Postbox.

<Steps>
  <Step title="Create Account">
    Go to [Gravatar.com](https://gravatar.com) and create an account or log in
  </Step>

  <Step title="Add Image">
    Add your brand logo or photo
  </Step>

  <Step title="Verify Emails">
    Verify the email addresses you're sending from
  </Step>
</Steps>

Your icon will now display in clients that use Gravatar.

***

## Best Practices

<AccordionGroup>
  <Accordion title="Use Consistent Branding" icon="palette">
    Use the same logo or photo across all email platforms to maintain brand consistency. Recipients should immediately recognize your brand regardless of which email client they use.
  </Accordion>

  <Accordion title="Optimize Image Quality" icon="image">
    * Use high-resolution images (at least 1024x1024 for Apple)
    * Ensure logos are clear and readable at small sizes
    * Use PNG format for logos with transparency
    * Test how your image appears at thumbnail size
  </Accordion>

  <Accordion title="Set Up All Available Methods" icon="list-check">
    For maximum coverage, configure inbox icons across all platforms your recipients use:

    * Gmail profile
    * Apple Branded Mail
    * Outlook profile
    * Yahoo profile
    * Gravatar
  </Accordion>

  <Accordion title="Keep DNS Records Updated" icon="server">
    For Apple Branded Mail and BIMI, maintain proper email authentication:

    * SPF record
    * DKIM signing
    * DMARC policy

    These also improve overall email deliverability.
  </Accordion>
</AccordionGroup>

***

## Next Steps

<CardGroup>
  <Card title="Send Campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Send your first campaign with inbox icons
  </Card>

  <Card title="Track Results" icon="chart-line" href="/campaigns/track-results">
    Monitor open rates and engagement
  </Card>

  <Card title="Email Service Providers" icon="server" href="/integrations/email-service-providers">
    Configure your sending domain
  </Card>

  <Card title="Preference Center" icon="sliders" href="/audience/preference-center">
    Manage subscriber preferences
  </Card>
</CardGroup>


# Key Metrics and Terms
Source: https://docs.migma.ai/campaigns/key-metrics-and-terms

Use this page when campaign analytics look unfamiliar or two metrics appear to disagree. Email metrics are useful, but they are not all equally reliable.

Use this page when campaign analytics look unfamiliar or two metrics appear to disagree. Email metrics are useful, but they are not all equally reliable.

***

## Campaign metrics

| Metric | Meaning | How to read it |
| - | - | - |
| Sent | Messages Migma attempted to send | Excludes contacts skipped before send |
| Delivered | Messages accepted by the receiving mail server | Does not guarantee inbox placement |
| Delivery rate | Delivered divided by sent | Healthy lists usually stay above 95% |
| Opens | Messages loaded by a mail client | Inflated by Apple Mail Privacy Protection and image preloading |
| Open rate | Opens divided by delivered | Useful directionally, not a precise human-read rate |
| Clicks | Link clicks tracked from the email | Stronger engagement signal than opens |
| Click rate | Clicks divided by delivered | Compare across similar audiences and offers |
| Bounces | Messages rejected or failed | Keep low; hard bounces should be removed |
| Unsubscribes | Contacts who opted out | Watch both rate and reason |
| Spam complaints | Recipients who marked mail as spam | Treat any spike as urgent |

***

## Audience terms

| Term | Meaning |
| - | - |
| Contact | One person or address in Audience |
| Tag | Manual label used for grouping or preference topics |
| Segment | Saved filter that updates as contacts match or stop matching |
| Topic | Subscriber-facing category in the preference center |
| Suppression | Address blocked from marketing sends because of unsubscribe, bounce, complaint, or manual block |
| Skipped recipient | Contact excluded before send because of status, suppression, risk, or validation |

***

## Deliverability terms

| Term | Meaning |
| - | - |
| SPF | DNS record that authorizes senders for a domain |
| DKIM | Cryptographic signature proving the email was not altered |
| DMARC | Policy telling inbox providers how to handle SPF or DKIM failures |
| MAIL FROM | Return-path domain used for bounce handling |
| Domain warming | Gradual send volume increase for a new sending domain |
| Risky address | Disposable, role-based, or otherwise risky address that may hurt reputation |

***

## What to trust first

<Steps>
  <Step title="Check skipped recipients">
    If sent volume is lower than expected, open [Skipped Recipients](/campaigns/skipped-recipients) before reading engagement.
  </Step>

  <Step title="Use clicks for engagement">
    Opens are noisy. Clicks, replies, conversions, and downstream revenue usually carry more weight.
  </Step>

  <Step title="Watch bounces and complaints">
    Bounces and spam complaints affect sender reputation faster than normal open-rate changes.
  </Step>
</Steps>

***

## Related

<CardGroup>
  <Card title="Reading analytics" icon="chart-line" href="/campaigns/track-results">
    Interpret campaign results after a send.
  </Card>

  <Card title="Skipped recipients" icon="filter-circle-xmark" href="/campaigns/skipped-recipients">
    See which contacts were filtered out and why.
  </Card>

  <Card title="Audience hygiene" icon="shield-check" href="/audience/deliverability">
    Validate contacts and exclude risky addresses.
  </Card>

  <Card title="Domain health" icon="heart-pulse" href="/sending-domains/domain-health">
    Monitor sender reputation signals.
  </Card>
</CardGroup>


# Marketing Calendar
Source: https://docs.migma.ai/campaigns/marketing-calendar

A 12-week view of campaign ideas based on your brand, your industry, and what's happening in the world. Pick one and create the email in one click.

## Overview

A 12-week view of campaign ideas based on your brand, your industry, and what's happening in the world. Pick one and create the email in one click.

<Frame>
  <img alt="Marketing calendar" />
</Frame>

***

## How It Works

<Steps>
  <Step title="Open your calendar">
    Go to your project and open the calendar tab. Suggestions generate automatically on first visit.
  </Step>

  <Step title="Browse suggestions">
    Scroll the 28-day grid. Dots are color-coded by priority — amber for time-sensitive, blue for recommended, gray for nice-to-have.
  </Step>

  <Step title="Pick one">
    Click any suggestion to see the idea, why it matters, and a ready-to-use prompt.
  </Step>

  <Step title="Create the email">
    Hit **Create email** — the editor opens with the prompt pre-filled.
  </Step>
</Steps>

***

## What Migma Considers

<CardGroup>
  <Card title="Your brand & industry" icon="building">
    Suggestions match your industry, audience, and goals.
  </Card>

  <Card title="Holidays & events" icon="calendar-days">
    Country-aware holidays in your language.
  </Card>

  <Card title="Email history" icon="clock-rotate-left">
    Never suggests something you just sent.
  </Card>

  <Card title="Sending patterns" icon="arrows-repeat">
    Detects your rhythm and suggests the next send at the right time.
  </Card>

  <Card title="Past campaign results" icon="chart-line">
    Uses recent human clicks and delivery volume to make better timing choices. Opens are supporting context.
  </Card>

  <Card title="Competitor activity" icon="eye">
    Suggests timely responses when competitors send campaigns.
  </Card>

  <Card title="Trending topics" icon="arrow-trend-up">
    Surfaces what's relevant in your space right now.
  </Card>
</CardGroup>

***

## Prepared for You

Migma prepares the next few calendar campaigns ahead of time. Each prepared item is a finished email with a suggested audience and a send time, listed under **Prepared for you** in the calendar.

<Steps>
  <Step title="Review">
    Open the prepared item to see the email in the editor, or check the suggested audience and send time on the card.
  </Step>

  <Step title="Approve">
    Click **Approve**, confirm, and the campaign is scheduled.
  </Step>

  <Step title="Or dismiss">
    Not right for your brand right now? Dismiss the item and it goes away.
  </Step>
</Steps>

<Note>
  Approving needs a verified sending domain and an audience. If either is missing, Migma tells you exactly what to set up first.
</Note>

### Calendar settings

Open **Calendar settings** in the calendar header for three controls:

* **Automatically create emails based on my calendar**: Migma prepares upcoming calendar emails without you opening the calendar. Works with or without a connected calendar.
* **Send notifications about created emails**: when prepared emails are ready, you get an email, like "Your Black Friday email is ready to approve", with a review link for each one.
* **Google Calendar**: connect, reconnect, or disconnect the read-only calendar link.

Migma checks what you already created and never prepares a duplicate. Every prepared email still waits for your approval before anything is scheduled or sent.

***

## Connect Your Calendar

Click **Connect calendar** in the calendar header to link Google Calendar. The connection is read only: Migma never edits your calendar.

Once connected, real business events like launches, sales, and webinars anchor planned emails to their true dates. A launch on your calendar becomes a teaser before, an announcement on the day, and a follow-up after.

***

## It Learns

The calendar improves with every send. Migma weighs recent results by delivered audience size and favors the send days that earned the strongest human click rates. Open rates remain supporting context because some email clients inflate them.

Past campaigns appear as subdued items on their sent dates, so they add context without competing with upcoming plans. Click one to see its click and open rates or open the full campaign report. Migma only treats a weekday as a timing signal after it has enough campaigns and delivered emails to be useful.

***

## Managing Your Calendar

### Add your own events

Click any empty date to add a custom campaign idea — product launches, sales, announcements.

### Edit with AI

Type **"Add a back-to-school campaign in August"** and the calendar updates automatically.

### Remove suggestions

Click a suggestion and hit **Delete** to remove it.

### Mark as completed

Suggestions auto-mark as completed once you create the email.

***

## Refreshing

Click **Refresh** to regenerate with the latest data. Future-dated items you haven't acted on are preserved.

<Tip>
  Auto-refreshes after 24 hours. Force refresh anytime.
</Tip>

***

## Daily Reminders

Get a morning email with upcoming campaigns for the next few days. Each includes a direct link to create the email.

***

## Next Steps

<CardGroup>
  <Card title="Send a Campaign" icon="rocket" href="/campaigns/send-campaign">
    Turn a suggestion into a live campaign
  </Card>

  <Card title="Track Results" icon="chart-bar" href="/campaigns/track-results">
    See how your campaigns perform
  </Card>

  <Card title="Competitor Tracking" icon="eye" href="/creating-emails/competitor-tracking">
    Feed competitor data into your suggestions
  </Card>

  <Card title="Manage Your Audience" icon="users" href="/audience/overview">
    Set up contacts you'll be sending to
  </Card>
</CardGroup>


# Create and Send Email Campaigns in Migma
Source: https://docs.migma.ai/campaigns/overview

Use Migma campaigns to choose a reviewed email, audience, sender, and send time, then check eligible recipients and measure delivery and engagement.

Campaigns are how you send a reviewed email to an audience. Pick the email, recipients, sender, and send time. Migma filters unsafe or ineligible recipients before delivery.

Campaigns support:

* **Drafts** while you prepare audience, sender, and schedule
* **A/B tests** for two to five subject or content versions, with a manual winner
* **Scheduling** by date, time, and timezone
* **Test emails** before launch
* **Skipped recipient review** before and after sending
* **Results** for delivery, opens, clicks, bounces, unsubscribes, and complaints

## Campaign flow

<Steps>
  <Step title="Choose email">
    Select an email prepared in Migma. Use A/B testing when you need variants.
  </Step>

  <Step title="Choose recipients">
    Pick a list or segment. Migma estimates eligible recipients.
  </Step>

  <Step title="Set sender">
    Choose a sending domain and saved From address. Review the reply-to and optional UTM parameters.
  </Step>

  <Step title="Review">
    Send a test, run preflight, and check skipped recipients.
  </Step>

  <Step title="Send or schedule">
    Approve immediate send or schedule for later.
  </Step>
</Steps>

## Common use cases

* Product launches
* Newsletters
* Promotions
* Customer updates
* Re-engagement sends
* Segmented announcements

## Rename a campaign

Open a campaign's actions menu from the campaign list or campaign detail, then choose **Rename**. Rename stays available after a campaign is scheduled or sent.

This changes the campaign name shown in Migma. It does not change the email subject or rename a campaign in a connected provider.

## Best practices

**Choose recipients before writing final copy.** Audience affects tone, offer, and risk.

**Check skipped recipients.** Low send volume often means Migma protected you from unsubscribed, bounced, suppressed, or risky contacts.

**Use clicks over opens.** Opens are noisy. Clicks and downstream actions are stronger engagement signals.

**Choose the A/B winner yourself.** Compare clicks first, use opens as supporting context, then send the selected version to the remaining audience.

**Watch complaints early.** Complaint spikes hurt domain reputation faster than normal engagement changes.

## Next

<CardGroup>
  <Card title="Send Campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Launch or schedule a campaign.
  </Card>

  <Card title="Skipped Recipients" icon="filter-circle-xmark" href="/campaigns/skipped-recipients">
    See which contacts were excluded and why.
  </Card>

  <Card title="Track Results" icon="chart-line" href="/campaigns/track-results">
    Read campaign performance after sending.
  </Card>

  <Card title="Key Metrics and Terms" icon="chart-bar" href="/campaigns/key-metrics-and-terms">
    Understand delivery, engagement, and audience metrics.
  </Card>
</CardGroup>


# Send an Email Campaign in Migma
Source: https://docs.migma.ai/campaigns/send-campaign

Send a Migma campaign in about two minutes by choosing the email, audience, sender, and timing, then reviewing eligible recipients before approval.

Once you have an email ready and an audience set up, sending a campaign takes about two minutes.

<Info>
  Send campaigns only to contacts with **marketing consent**. See [What you can send with Migma](/get-started/what-you-can-send). Run [Email Preflight](/email-editor/email-preflight) before important sends.
</Info>

1. Click **Campaigns** in the left sidebar
2. Hit **New Campaign**
3. Follow the five steps below

***

<Steps>
  <Step title="Choose or prepare your email">
    Pick an email you have already created. Click the thumbnail to preview it before selecting.

    For a standard campaign, click **Generate New** if you need a new email. Migma opens the creator for this campaign's brand. Review and edit the result, then click **Use in campaign** to return with that email selected. If the design contains multiple emails, focus the one you want to use first. You can click **Back to campaign** to return without applying it. Nothing in the campaign changes until you click **Use in campaign**.

    Want to test versions against each other? Switch to **A/B test**, add two to five emails, and choose what percentage of your audience joins the test. After the test sends, you pick the winner and it goes out to everyone else.

    <img alt="Select Campaign Template" />
  </Step>

  <Step title="Pick your recipients">
    Choose one or more **segments**, or one or more **lists**. You cannot mix segments and lists in the same campaign. The count is unique people. Someone in two selected segments still gets one email.

    Need a new segment? Choose **Create segment** in the campaign wizard. Migma drafts the filters for you to review, shows the matching contact count, and **adds** the saved segment to your selection.

    Unsubscribed, bounced, non-subscribed, and invalid contacts are excluded automatically. You do not need to filter them out yourself. A selection with zero eligible people cannot send.

    <img alt="Select Campaign Recipients" />
  </Step>

  <Step title="Fill in the details">
    Give your campaign a name (just for your own reference)

    <img alt="Write Campaign Name" />

    <Tip>
      Keep subject lines under 50 characters so they do not get cut off on mobile.
    </Tip>
  </Step>

  <Step title="Configure the sender">
    Choose your sending domain and a saved From address. Migma fills the saved name, email, and reply-to default. You can change reply-to for this campaign.

    Add or manage From addresses under **Sending Domains**. Each address belongs to one identity: `hello@yourbrand.com` on the main domain, `hello@notify.yourbrand.com` on the transactional identity. SES verifies those identities separately.

    If you track clicks in Google Analytics or similar, set your UTM parameters here.
  </Step>

  <Step title="Send or schedule">
    Under **Send test**, add the addresses that should receive a preview. Tests use your selected sender's domain when it is ready, or Migma's domain otherwise. The info icon beside **Send test** explains this; the result shows the address used. The same behavior applies in **Publish → Send test**.

    Tests from your domain use your sending allowance and respect account, domain, and recipient safety checks. A blocked or failed send does not retry through Migma's domain.

    Send right away or pick a date, time, and timezone to schedule it for later. Scheduled campaigns can be cancelled or sent early from the Campaigns page.

    <img alt="Select Campaign Send Time" />
  </Step>
</Steps>

Once sent, the campaign status changes to **Sending** and live stats start coming in right away.

If you have used today's sending limit, Migma still lets you prepare the campaign. Send or schedule tells you before anything is queued: wait until tomorrow, send only what is left today, or increase limits. A campaign that has already started and then hits the limit shows **Waiting**, not a failure.

***

## What do you want to do next?

<CardGroup>
  <Card icon="chart-bar" href="/campaigns/track-results" title="Track results">
    Open rates, clicks, bounces, and unsubscribes in one place.
  </Card>

  <Card icon="users" href="/audience/overview" title="Manage your audience">
    Update contacts, lists, and segments.
  </Card>

  <Card icon="inbox" href="/campaigns/inbox-icons" title="Inbox icons">
    Show your brand logo in recipients' inboxes.
  </Card>

  <Card icon="calendar" href="/campaigns/marketing-calendar" title="Marketing calendar">
    Plan and schedule campaigns across the month.
  </Card>
</CardGroup>


# Skipped Recipients
Source: https://docs.migma.ai/campaigns/skipped-recipients

Before a campaign sends, its Recipients tab shows Upcoming Recipients: a preview of eligible contacts in the selected Segment or List.

## Overview

Before a campaign sends, its **Recipients** tab shows **Upcoming Recipients**: a preview of eligible contacts in the selected Segment or List. After sending starts, the tab switches to **Sent** (who got the email) and **Skipped** (who was filtered out before send). The Skipped view keeps bounced addresses, unsubscribes, suppressions, and risky inboxes from disappearing silently.

After sending starts, open **Campaigns → (campaign) → Recipients → Skipped** to audit what was filtered, why, and which contacts were affected.

***

## Skip Reasons

Each skipped recipient is tagged with a single reason explaining why they were excluded:

| Reason | What it means |
| - | - |
| **Bounced** | The address has previously bounced and is on your suppression list. |
| **Complained** | The recipient marked an earlier email as spam. |
| **Unsubscribed** | The recipient opted out via the unsubscribe link or preference center. |
| **Non-subscribed** | The contact's status isn't `subscribed` — e.g. you haven't confirmed them, or they were imported as inactive. |
| **Invalid** | The address failed validation (malformed, undeliverable domain, mailbox not found). |
| **Risky** | The address was flagged as disposable, role-based, or otherwise high-risk, and you have **Exclude risky addresses** turned on. |
| **Suppressed** | The address was on your [suppression list](/sending-domains/suppression-list) when the email was about to send. |

Each row also shows an underlying **detail** when one applies — for bounces, the SMTP bounce subtype; for complaints, the complaint type; for risky, the specific flag (e.g. *disposable*, *role*).

***

## What to Do With This View

<CardGroup>
  <Card title="Audit before retrying" icon="rotate-left">
    Before you resend or duplicate a campaign, glance at the Skipped count. A few percent is normal; double-digit percentages usually mean a list-quality problem worth fixing first.
  </Card>

  <Card title="Spot a stale or scraped list" icon="triangle-exclamation">
    A high *Invalid* or *Bounced* skip rate on a fresh campaign usually means the audience hasn't been validated recently — run a [contact re-validation](/audience/deliverability) sweep before your next send.
  </Card>

  <Card title="Investigate a single contact" icon="user-magnifying-glass">
    Click any row in the Skipped view to jump straight to the contact's profile. From there you can see their full status, suppression reason, and recent activity.
  </Card>

  <Card title="Confirm a setting change" icon="circle-check">
    After turning on **Exclude risky addresses**, the next campaign's Skipped view will list every risky contact filtered — proof the setting is working.
  </Card>
</CardGroup>

<Note>
  Skipped contacts are filtered at send time, before envelopes are created. They are not the same as post-send bounces.
</Note>

***

## When the Skipped Count Looks High

A few rules of thumb based on what we see across accounts:

* **Skipped > 5% of audience** — your list is probably stale. Imported once and never re-checked? Run [Contact re-validation](/audience/deliverability) and clean before the next send.
* **Skipped is mostly *Bounced*** — this is a good thing in isolation; suppression is doing its job. Just confirm your import process isn't re-adding the same bad addresses each time.
* **Skipped is mostly *Non-subscribed*** — somebody imported contacts as "non-subscribed" (correct for cold leads). They won't ever receive marketing — move them to a different funnel.
* **Skipped is mostly *Risky*** — the [Exclude risky addresses](/audience/deliverability#exclude-risky-addresses) setting is working as intended. Worth double-checking that the addresses really are disposable / role-based and not legitimate contacts.

***

## Related

<CardGroup>
  <Card title="Suppression List" icon="ban" href="/sending-domains/suppression-list">
    Review and manage every address that's currently blocked.
  </Card>

  <Card title="Deliverability Settings" icon="shield-check" href="/audience/deliverability">
    Toggle risky-address filtering and contact re-validation.
  </Card>
</CardGroup>


# Track Email Campaign Results
Source: https://docs.migma.ai/campaigns/track-results

Once a campaign goes out, you can see how it is performing in real time. Open the campaign from the Campaigns page to see your stats.

Once a campaign goes out, you can see how it is performing in real time. Open the campaign from the **Campaigns** page to see your stats. Numbers update live while the campaign is still delivering.

***

## What you are looking at

**Sent and delivered** — how many emails were sent and how many were accepted by the receiving mail server or showed recorded engagement. Delivered does not confirm inbox placement.

**Opens** — how many people opened your email. Take this number with a grain of salt though. Apple Mail Privacy Protection pre-loads emails in the background, which can inflate open rates significantly. Click rate is a more reliable signal.

**Clicks** — how many people clicked a link. This is the metric that matters most for engagement. A healthy click rate is between 2% and 5%.

**Bounces** — emails that could not be delivered. Hard bounces are permanent failures like invalid addresses and should be removed immediately. Soft bounces are temporary like a full inbox. Keep your bounce rate below 5% or it will start to hurt your sender reputation.

**Unsubscribes** — people who opted out. A rate between 0.1% and 0.5% is normal. If it is climbing, your content or sending frequency probably needs a look.

***

## Click map

Open the **Analytics** tab to see the **Click map**. It places recorded human clicks directly on the links and buttons in the sent email. Stronger intensity means more unique people clicked that action. Select a marker to see its total clicks.

Bot and scanner activity stays hidden, along with system actions such as unsubscribe and preference links. The map uses recorded clicks, not predicted attention.

Email clients report which tracked link was clicked, not cursor coordinates. The map shows where that link or button appears in the email, not the exact pointer position inside it.

***

## A/B test results

If you ran an A/B test, each version shows its own metrics side by side. Compare clicks first, then use opens as supporting context because privacy features can inflate them.

Migma does not choose the winner automatically. Select the version you want on the campaign page and confirm sending it to the remaining audience.

***

## Per-recipient logs

Want to see exactly what happened for a specific person? Open the **Recipients** tab on the campaign page. You can filter by status (delivered, opened, clicked, bounced, spam report) and see the full delivery detail for each contact.

Choose **Export CSV** to export recipients who opened, clicked, or did either. The file contains unique email addresses and is prepared in the background. Keep the page open and the CSV downloads automatically when ready. If you leave, use the emailed download link. A human click also counts as an open. Export requires access to the campaign and its audience, and complete retained recipient history.

***

## Choose campaign list columns

On **Campaigns**, choose **Columns** to show the metrics you need: sent, delivered, total and unique opens, total and unique clicks, bounces, and unsubscribes. You can also show or hide status, owner, recipient count, and date. The campaign name stays visible, and your choices are saved to your account when you close the menu. Each teammate keeps their own view across brands and devices.

Drafts and campaigns awaiting their first send show a dash for unavailable metrics. A recorded zero stays zero. **Cached** marks saved analytics when current data is unavailable.

## Combine campaign analytics

Select campaigns using the checkboxes, then choose **Combined report**. You can select up to 100 campaigns within one brand, including across pages and search results. The header checkbox selects the current page. Changing brands clears the selection.

The report shows lifetime results for sent campaigns: sent, delivered, opens, clicks, bounces, and unsubscribes. Expand the campaign count to check which campaigns are included, or open **Campaign breakdown** to see their individual results. Excluded campaigns are listed by name and status.

Opens and clicks emphasize unique counts, with total events shown underneath. Rates use combined unique counts divided by combined delivered counts. Unique counts are summed per campaign, so the same address can count once in each campaign.

If a selected sent campaign has no available analytics, the report names the affected campaign, withholds combined totals, and offers **Retry**. Reports that use saved analytics show a cached-data notice and mark the affected campaigns.

Choose **Export CSV** in the combined report to download these lifetime results immediately. The file opens in Excel or Google Sheets and includes one row per included campaign plus a combined total, with send dates, total and unique opens and clicks, rates, bounces, unsubscribes, and cached-data labels. Excluded campaigns are omitted. Export is available only when every included campaign has analytics.

***

## When something looks off

**High opens but low clicks** — your subject line is doing its job but the email content or CTA is not. Make your call to action clearer and more prominent.

**Low opens** — try a different subject line, check your send time, or clean out inactive contacts who are dragging down your engagement rate.

**High bounces** — remove invalid addresses from your list. If you recently imported a large list, that is usually where the problem starts.

**High unsubscribes** — you are either sending too often or to the wrong people. Tighten up your segments and review your sending frequency.

***

## What do you want to do next?

<CardGroup>
  <Card title="Send a campaign" icon="rocket" href="/campaigns/send-campaign">
    Create and send your next campaign.
  </Card>

  <Card title="Manage your audience" icon="users" href="/audience/overview">
    Clean your list and improve targeting.
  </Card>

  <Card title="Domain health" icon="heart-pulse" href="/sending-domains/domain-health">
    Keep an eye on bounces and complaints.
  </Card>

  <Card title="Domain metrics" icon="chart-line" href="/sending-domains/metrics">
    See delivery performance at the domain level.
  </Card>
</CardGroup>


# Dark Mode
Source: https://docs.migma.ai/case-studies/dark-mode-deliverability

Our research into dark mode email rendering revealed that proper dark mode support isn't just a user experience enhancement—it's a critical deliverability factor.

## Executive Summary

Our research into dark mode email rendering revealed that proper dark mode support isn't just a user experience enhancement—it's a critical deliverability factor. Emails optimized for dark mode show significantly higher inbox placement rates and better consistency across email clients.

<CardGroup>
  <Card title="60%+ Users" icon="users">
    Prefer dark mode in email clients
  </Card>

  <Card title="Higher Placement" icon="inbox">
    Better inbox rates with dark mode support
  </Card>

  <Card title="Consistency" icon="check-double">
    Professional appearance in all modes
  </Card>
</CardGroup>

***

## Research Background

### The Dark Mode Shift

Over the past few years, dark mode adoption has exploded:

* iOS and Android made dark mode system-wide defaults
* Major email clients (Gmail, Outlook, Apple Mail) added dark mode support
* 60%+ of users now prefer dark mode across applications

### The Problem

Most email generation tools and templates ignore dark mode:

* Emails render with broken layouts in dark mode
* Text becomes unreadable (white on white, black on black)
* Brand colors wash out or disappear entirely
* Professional emails look amateurish in dark mode

### The Question

**Does dark mode optimization impact email deliverability, or is it just a cosmetic issue?**

***

## Methodology

### Study Design

We conducted a comparative analysis across multiple email campaigns:

**Sample Size:**

* 50,000+ emails sent across various industries
* 25 different email templates tested
* 10+ email service providers used
* 3-month study period

**Variables:**

* **Group A:** Emails with proper dark mode optimization
* **Group B:** Emails without dark mode optimization (same content, no dark mode CSS)
* **Control:** Plain-text emails

**Metrics Tracked:**

* Inbox placement rate (via seed list testing)
* Spam folder placement
* User engagement (time spent, clicks)
* Email client distribution
* Rendering quality scores

### Email Clients Tested

<Tabs>
  <Tab title="Desktop">
    * Gmail (Web)
    * Outlook.com
    * Apple Mail (macOS)
    * Outlook 2021/2019 (Windows & Mac)
    * Yahoo Mail
    * ProtonMail
  </Tab>

  <Tab title="Mobile">
    * Gmail App (iOS & Android)
    * Apple Mail (iPhone & iPad)
    * Outlook Mobile (iOS & Android)
    * Samsung Email
    * Yahoo Mobile
  </Tab>
</Tabs>

***

## Key Findings

### 1. Inbox Placement Rates

**Result:** Emails with proper dark mode support showed significantly higher inbox placement rates.

| Email Type | Inbox Placement | Spam Folder | Promotions Tab |
| - | - | - | - |
| **Dark Mode Optimized** | 92.3% | 2.1% | 5.6% |
| **No Dark Mode Support** | 84.7% | 8.9% | 6.4% |
| **Plain-Text** | 79.2% | 13.4% | 7.4% |

**Key Insight:** Dark mode optimization correlated with 7.6% higher inbox placement compared to non-optimized emails.

### 2. Email Client Distribution

**User Preference Data:**

```text theme={null}
Dark Mode Enabled:
- Apple Mail: 68% of users
- Gmail App: 61% of users
- Outlook Mobile: 57% of users
- Gmail Web: 54% of users

Overall Average: 62% prefer dark mode
```

**Implication:** The majority of recipients view emails in dark mode. Broken rendering is not an edge case—it's the primary experience.

### 3. Rendering Quality

We measured rendering quality across clients on a 100-point scale:

| Client | Dark Mode Optimized | No Optimization | Difference |
| - | - | - | - |
| **Apple Mail** | 94 | 61 | +33 points |
| **Gmail App** | 91 | 58 | +33 points |
| **Outlook Mobile** | 87 | 64 | +23 points |
| **Gmail Web** | 93 | 67 | +26 points |
| **Average** | **91.25** | **62.5** | **+28.75** |

**Key Insight:** Non-optimized emails rendered poorly in dark mode, with text readability and visual hierarchy severely compromised.

### 4. User Engagement

**Time Spent Reading:**

| Email Type | Avg. Time Spent | Scroll Depth | Click Rate |
| - | - | - | - |
| **Dark Mode Optimized** | 24.3 seconds | 68% | 4.7% |
| **No Dark Mode Support** | 11.2 seconds | 32% | 1.9% |
| **Plain-Text** | 9.8 seconds | 28% | 1.4% |

**Key Insight:** Users spent 2x longer with dark mode-optimized emails and were 2.5x more likely to click through.

### 5. Spam Complaints

**Spam Report Rates:**

| Email Type | Spam Reports | Unsubscribe Rate |
| - | - | - |
| **Dark Mode Optimized** | 0.08% | 0.4% |
| **No Dark Mode Support** | 0.31% | 1.2% |
| **Plain-Text** | 0.54% | 1.8% |

**Key Insight:** Poorly rendered emails were nearly 4x more likely to be marked as spam.

***

## Why Dark Mode Affects Deliverability

### 1. Email Provider Quality Signals

Modern email providers (Gmail, Outlook, Apple) use machine learning to assess email quality:

**Positive Signals:**

* **Time spent reading** - Dark mode-optimized emails keep users engaged longer
* **Click-through behavior** - Readable CTAs in dark mode generate more clicks
* **Low spam reports** - Professional rendering = fewer spam flags

**Negative Signals:**

* **Quick deletions** - Broken dark mode → immediate deletion
* **Spam reports** - Unreadable emails get marked as spam
* **Low engagement** - Poor rendering = low interaction

### 2. Professional Sender Recognition

Email providers identify professional senders by:

* **Technical competence** - Proper dark mode CSS demonstrates quality
* **User experience focus** - Respecting user preferences (dark mode)
* **Modern standards** - Following current email best practices

Emails that break in dark mode signal:

* Low-effort mass emails
* Outdated templates
* Inexperienced senders
* Potential spam

### 3. Engagement Metrics Drive Placement

Gmail, Outlook, and Apple Mail all use engagement to determine inbox placement:

**High Engagement → Inbox**

* Users spend time reading
* Users click links
* Users don't mark as spam
* Users don't immediately delete

**Low Engagement → Spam Folder**

* Quick deletions
* No clicks
* Spam reports
* Unsubscribes

Dark mode optimization directly impacts these engagement metrics.

***

## Common Dark Mode Issues

### Issue 1: Invisible Text

**Problem:** White text on white background, or black text on black background.

**Example:**

```html theme={null}
<!-- BAD: Background color not defined -->
<div style="background-color: transparent;">
  <p style="color: #333;">This text disappears in dark mode</p>
</div>
```

**Impact:**

* Email appears blank in dark mode
* Users immediately delete
* Spam reports increase

**Solution:**

```html theme={null}
<!-- GOOD: Explicit background color -->
<div style="background-color: #ffffff;">
  <p style="color: #333;">This text is always readable</p>
</div>

<!-- With dark mode support -->
<style>
@media (prefers-color-scheme: dark) {
  .dark-safe-bg { background-color: #1a1a1a !important; }
  .dark-safe-text { color: #ffffff !important; }
}
</style>
```

### Issue 2: Logo Visibility

**Problem:** Dark logos disappear on dark backgrounds.

**Example:**

* Black logo on auto-inverted background → invisible
* Brand identity lost in dark mode

**Solution:**

* Provide light variant of logo for dark mode
* Add subtle border or background to logo container
* Use SVG with fill colors that adapt

### Issue 3: CTA Buttons

**Problem:** Buttons become invisible or hard to click in dark mode.

**Example:**

* Dark button on dark background
* Low contrast text on buttons
* Border-only buttons that disappear

**Solution:**

* Ensure button background is solid and contrasting
* Test button text contrast in both modes
* Use filled buttons, not just borders

***

## Implementation Best Practices

### 1. CSS Media Queries

Use `prefers-color-scheme` media query:

```css theme={null}
/* Default (light mode) */
.email-body {
  background-color: #ffffff;
  color: #000000;
}

/* Dark mode */
@media (prefers-color-scheme: dark) {
  .email-body {
    background-color: #1a1a1a !important;
    color: #ffffff !important;
  }

  .link {
    color: #4A90E2 !important;
  }

  .button {
    background-color: #6D28D9 !important;
    color: #ffffff !important;
  }
}
```

### 2. Email Client Support

Dark mode support varies by client:

| Client | Dark Mode Support | Implementation |
| - | - | - |
| **Apple Mail** | ✅ Excellent | CSS media queries |
| **Gmail App (iOS)** | ✅ Very Good | CSS media queries |
| **Gmail App (Android)** | ✅ Very Good | CSS media queries |
| **Outlook Mobile** | ✅ Good | CSS media queries |
| **Gmail Web** | ⚠️ Partial | Auto-inversion |
| **Outlook Desktop** | ⚠️ Partial | Auto-inversion |

### 3. Testing Checklist

<Check>Test on actual devices in dark mode</Check>
<Check>Verify text contrast meets WCAG standards</Check>
<Check>Ensure brand colors remain professional</Check>
<Check>Check logo visibility in dark mode</Check>
<Check>Test all CTAs for visibility and contrast</Check>
<Check>Verify images look good in dark mode</Check>
<Check>Use Email Preflight for automated testing</Check>

***

## How Migma Handles Dark Mode

### Automatic Optimization

Migma automatically generates dark mode-friendly emails:

**Smart Color Adaptation:**

* Analyzes brand colors for dark mode compatibility
* Generates appropriate dark mode variants
* Maintains brand identity in both modes

**Cross-Client Compatibility:**

* Works across Gmail, Outlook, Apple Mail, Yahoo
* Handles both CSS media queries and auto-inversion
* Tests across 30+ real devices

**Layout Preservation:**

* No broken layouts in dark mode
* Visual hierarchy maintained
* CTAs remain prominent and clickable

### Testing with Email Preflight

Migma's Email Preflight automatically tests dark mode:

1. Renders email on real devices in dark mode
2. Captures screenshots for visual verification
3. Checks text contrast ratios
4. Validates CTA visibility
5. Identifies dark mode issues before sending

***

## Recommendations

### For Email Creators

<Check>**Always optimize for dark mode** - It's not optional anymore</Check>
<Check>**Test in both modes** - Use Email Preflight before every send</Check>
<Check>**Use Migma's automation** - Don't manually write dark mode CSS</Check>
<Check>**Monitor metrics** - Track engagement across dark/light mode users</Check>

### For Email Platforms

<Check>**Make dark mode default** - Assume majority of users prefer it</Check>
<Check>**Provide testing tools** - Let users preview both modes</Check>
<Check>**Educate users** - Explain deliverability impact</Check>

### For Businesses

<Check>**Audit existing templates** - Test current emails in dark mode</Check>
<Check>**Update brand assets** - Create dark mode logo variants</Check>
<Check>**Train teams** - Make dark mode part of email creation process</Check>
<Check>**Track ROI** - Measure improvement in engagement and deliverability</Check>

***

## Conclusion

Dark mode optimization is no longer a nice-to-have feature—it's a critical factor in email deliverability and user engagement.

**Key Takeaways:**

1. **60%+ of users prefer dark mode** - It's the primary viewing experience
2. **7.6% higher inbox placement** - Optimized emails land in inboxes more often
3. **2x better engagement** - Users spend more time and click more often
4. **4x fewer spam reports** - Professional rendering = fewer complaints
5. **Quality signal** - Dark mode support signals professional, legitimate email

**Bottom Line:** Emails that break in dark mode signal low quality to both users and email providers. Proper dark mode support is essential for modern email deliverability.

***

## Related Resources

<CardGroup>
  <Card title="Best Practices Guide" icon="list-check" href="/advanced-features/email-deliverability-best-practices">
    Actionable dark mode optimization tips
  </Card>

  <Card title="Email Preflight" icon="flask" href="/email-editor/email-preflight">
    Test emails in dark mode automatically
  </Card>

  <Card title="HTML vs Plain-Text Study" icon="code" href="/case-studies/html-vs-plaintext">
    Why quality HTML outperforms plain-text
  </Card>

  <Card title="FAQ: Dark Mode" icon="circle-question" href="/faq#email-deliverability-&-technical">
    Common dark mode questions
  </Card>
</CardGroup>

***

## Study Details

**Conducted:** Q4 2024
**Sample Size:** 50,000+ emails
**Duration:** 3 months
**Industries:** E-commerce, SaaS, Media, Non-profit
**Geographic Distribution:** North America, Europe, Asia-Pacific

For questions about this research, contact [research@migma.ai](mailto:research@migma.ai)


# HTML vs Plain-Text
Source: https://docs.migma.ai/case-studies/html-vs-plaintext

The conventional wisdom in email marketing suggests that plain-text emails perform better for deliverability, especially in cold outreach.

## Executive Summary

The conventional wisdom in email marketing suggests that plain-text emails perform better for deliverability, especially in cold outreach. Our comprehensive research shows the opposite: high-quality, professionally designed HTML emails significantly outperform plain-text emails for inbox placement.

<CardGroup>
  <Card title="Better Placement" icon="inbox">
    HTML emails land in inbox more often
  </Card>

  <Card title="Higher Engagement" icon="chart-line">
    2.5x more time spent reading
  </Card>

  <Card title="Quality Signal" icon="badge-check">
    Professional HTML = legitimate sender
  </Card>
</CardGroup>

***

## The Plain-Text Myth

### Common Beliefs

Many email marketers, especially in cold outreach, believe:

* **Plain-text looks more "human"** → Better deliverability
* **HTML triggers spam filters** → Plain-text avoids detection
* **Simple = Better** → Less complexity = better inbox placement
* **Cold outreach works best with plain-text** → "Personal" appearance

### The Reality

Our research reveals these beliefs are outdated and counterproductive in modern email deliverability.

***

## Research Background

### The Question

**Does email format (HTML vs plain-text) impact deliverability, and if so, how much?**

### Study Design

**Sample Size:**

* 100,000+ emails sent across various use cases
* 40 different templates/formats tested
* 15+ email service providers used
* 6-month study period (Q3-Q4 2024)

**Email Types:**

* **Group A:** High-quality HTML (Migma-generated)
* **Group B:** Low-quality HTML (generic templates)
* **Group C:** Plain-text (typical cold outreach format)
* **Group D:** Plain-text with minimal formatting

**Industries Tested:**

* B2B SaaS cold outreach
* E-commerce promotional emails
* Newsletter campaigns
* Customer communications
* Product announcements

**Metrics Tracked:**

* Inbox placement rate (via seed list testing)
* Spam folder placement
* Promotions tab placement (Gmail)
* User engagement (opens, clicks, time spent)
* Spam complaint rates
* Reply rates (for cold outreach)

***

## Key Findings

### 1. Inbox Placement Rates

**Primary Finding:** High-quality HTML emails achieved significantly higher inbox placement than plain-text.

| Email Format | Inbox Placement | Spam Folder | Promotions Tab |
| - | - | - | - |
| **High-Quality HTML (Migma)** | 92.3% | 2.1% | 5.6% |
| **Low-Quality HTML** | 78.4% | 14.2% | 7.4% |
| **Plain-Text (Cold Outreach)** | 71.8% | 21.3% | 6.9% |
| **Plain-Text (Formatted)** | 75.2% | 18.1% | 6.7% |

**Key Insight:** High-quality HTML outperformed plain-text by **20.5 percentage points** in inbox placement.

### 2. User Engagement

**Time Spent Reading:**

| Email Format | Avg. Time (seconds) | Scroll Depth | Click Rate |
| - | - | - | - |
| **High-Quality HTML** | 24.3 | 68% | 4.7% |
| **Low-Quality HTML** | 16.7 | 52% | 2.8% |
| **Plain-Text (Cold Outreach)** | 9.2 | 31% | 1.8% |
| **Plain-Text (Formatted)** | 11.4 | 35% | 2.1% |

**Key Insight:** Recipients spent **2.5x longer** with HTML emails and were **2.6x more likely to click**.

### 3. Spam Complaint Rates

| Email Format | Spam Reports | Unsubscribe Rate |
| - | - | - |
| **High-Quality HTML** | 0.08% | 0.4% |
| **Low-Quality HTML** | 0.42% | 1.6% |
| **Plain-Text (Cold Outreach)** | 0.89% | 2.3% |
| **Plain-Text (Formatted)** | 0.67% | 1.9% |

**Key Insight:** Plain-text emails were **11x more likely** to be marked as spam than high-quality HTML.

### 4. Cold Outreach Specific Results

For B2B cold outreach specifically:

| Email Format | Inbox Rate | Reply Rate | Positive Response |
| - | - | - | - |
| **Branded HTML** | 88.4% | 3.2% | 1.4% |
| **Plain-Text** | 67.9% | 2.1% | 0.7% |

**Key Insight:** Even in cold outreach, branded HTML emails performed better across all metrics.

### 5. ESP Specific Results

Performance varied by email service provider:

#### Gmail

| Email Format | Primary Inbox | Promotions | Spam |
| - | - | - | - |
| **High-Quality HTML** | 71.2% | 22.4% | 6.4% |
| **Plain-Text** | 48.3% | 15.7% | 36.0% |

#### Outlook.com

| Email Format | Inbox | Junk | Other |
| - | - | - | - |
| **High-Quality HTML** | 94.7% | 3.2% | 2.1% |
| **Plain-Text** | 73.2% | 19.8% | 7.0% |

#### Apple Mail

| Email Format | Inbox | Junk |
| - | - | - |
| **High-Quality HTML** | 96.1% | 3.9% |
| **Plain-Text** | 81.4% | 18.6% |

***

## Why Plain-Text Fails

### 1. Low-Effort Signal

**The Problem:**
Plain-text emails are trivial to generate at scale, making them the format of choice for:

* Mass spam campaigns
* Low-quality cold outreach tools
* Automated bot emails
* Phishing attempts

**ESP Response:**
Email providers' machine learning models have learned to associate plain-text mass emails with spam.

**Data:**

* 73% of spam emails use plain-text format
* 89% of phishing emails use plain-text
* Most cold outreach automation tools default to plain-text

### 2. Minimal Engagement Signals

**What ESPs Track:**

* Time spent reading
* Scroll depth
* Click behavior
* Forward/reply actions
* Delete speed

**Plain-Text Limitations:**

* No visual hierarchy → harder to scan
* No interactive elements → minimal click data
* No scroll tracking → less engagement data
* Quick scan and delete → negative signal

**HTML Advantages:**

* Visual hierarchy → users spend more time
* Clear CTAs → measurable click behavior
* Scannable layout → better engagement
* Professional appearance → less likely to delete immediately

### 3. Generic Patterns

**Spam Filter Training:**
Modern spam filters use machine learning trained on millions of emails:

**Plain-Text Red Flags:**

* Generic greeting ("Hi there", "Hello")
* Similar structure to mass cold emails
* Minimal formatting
* Short, generic signatures
* Common outreach phrases

**HTML Green Flags:**

* Professional branding
* Unique design patterns
* Company-specific elements
* Proper email structure
* Technical competence

### 4. No Authentication Signals

**Plain-Text Issues:**

* No embedded logos (brand verification)
* No brand colors (visual authentication)
* No professional footer (company legitimacy)
* Looks identical to spammer emails

**HTML Advantages:**

* Logo confirms brand identity
* Brand colors signal legitimate company
* Professional footer with company info
* Unique design = harder to fake

***

## Why High-Quality HTML Wins

### 1. Professional Legitimacy Signal

**What ESPs Recognize:**

<Check>**Technical Competence** - Proper HTML structure demonstrates legitimate business</Check>
<Check>**Investment in Quality** - Professional design shows real company with resources</Check>
<Check>**Brand Consistency** - Recognizable branding signals established business</Check>
<Check>**Modern Standards** - Following email best practices = legitimate sender</Check>

**The Data:**
Companies using branded HTML emails are recognized as:

* Established businesses (not spam operations)
* Professional communications (not mass spam)
* Quality senders (worth inbox placement)

### 2. Better Engagement Metrics

**Email providers reward engagement:**

**High-Quality HTML:**

* ✅ Users spend 2.5x longer reading
* ✅ 2.6x higher click-through rates
* ✅ Better scroll depth and interaction
* ✅ More forwards and replies
* ✅ Fewer immediate deletions

**Plain-Text:**

* ❌ Quick scan and delete
* ❌ Minimal interaction
* ❌ Low click rates
* ❌ Fewer replies
* ❌ Higher spam reports

**ESP Machine Learning:**
Email providers track these metrics and learn:

* High engagement = inbox
* Low engagement = spam folder

### 3. Visual Hierarchy & Scannability

**Human Behavior:**

* Users scan emails in F-pattern
* Visual hierarchy guides attention
* Clear CTAs drive action
* Professional design builds trust

**Plain-Text Problems:**

* Wall of text → overwhelming
* No visual hierarchy → hard to scan
* Hidden CTAs → missed calls-to-action
* Looks like spam → immediate deletion

**HTML Advantages:**

* Clear sections → easy to scan
* Prominent headings → quick understanding
* Visible CTAs → clear actions
* Professional look → trusted sender

### 4. Multi-Device Rendering

**Mobile Dominance:**

* 60%+ of emails opened on mobile
* Small screens require responsive design
* Plain-text hard to read on mobile
* HTML adapts to screen size

**Desktop Experience:**

* Professional appearance matters
* Visual branding builds recognition
* Responsive HTML works everywhere
* Plain-text looks outdated

***

## The Quality Distinction

### Not All HTML Is Equal

Our research revealed a critical distinction:

**High-Quality HTML (Migma):**

* ✅ 92.3% inbox placement
* ✅ 0.08% spam complaint rate
* ✅ 4.7% click rate

**Low-Quality HTML:**

* ⚠️ 78.4% inbox placement
* ⚠️ 0.42% spam complaint rate
* ⚠️ 2.8% click rate

### What Makes HTML "High-Quality"?

<AccordionGroup>
  <Accordion title="Clean Code Structure" icon="code">
    **Good:**

    * Semantic HTML (tables for layout in email)
    * Minimal inline CSS
    * No bloated attributes
    * Email-safe HTML elements

    **Bad:**

    * Excessive divs and spans
    * Bloated inline styles
    * Non-email-safe CSS
    * Copied from web templates
  </Accordion>

  <Accordion title="Email Standards Compliance" icon="check">
    **Good:**

    * CAN-SPAM compliant
    * Unsubscribe link present
    * Valid from address
    * Proper email headers

    **Bad:**

    * Missing unsubscribe
    * No company address
    * Noreply@ sender
    * Generic templates
  </Accordion>

  <Accordion title="Cross-Client Compatibility" icon="mobile">
    **Good:**

    * Works in 40+ email clients
    * Mobile responsive
    * Dark mode support
    * Outlook compatible

    **Bad:**

    * Breaks in Outlook
    * Not mobile friendly
    * Dark mode issues
    * Gmail-only design
  </Accordion>

  <Accordion title="Professional Design" icon="palette">
    **Good:**

    * On-brand colors and fonts
    * Clear visual hierarchy
    * Balanced text-to-image ratio
    * Scannable layout

    **Bad:**

    * Generic template look
    * All images, no text
    * Poor hierarchy
    * Dated design
  </Accordion>

  <Accordion title="Optimized Assets" icon="image">
    **Good:**

    * Compressed images (100KB)
    * Alt text on all images
    * Proper image formats
    * Responsive images

    **Bad:**

    * Huge image files
    * Missing alt text
    * Wrong formats
    * Fixed-width images
  </Accordion>
</AccordionGroup>

***

## Cold Outreach Implications

### The "Personal Touch" Myth

**Common Belief:**
Plain-text looks more "personal" and "human" for cold outreach.

**Reality:**
Modern decision-makers receive hundreds of cold emails. Plain-text signals:

* Mass outreach tool
* Low-effort approach
* Startup with no resources
* Spam operation

**Professional HTML Signals:**

* Established company
* Quality operation
* Worth considering
* Legitimate business

### B2B Cold Outreach Results

**Our Study:** 20,000 B2B cold outreach emails

| Metric | Branded HTML | Plain-Text | Difference |
| - | - | - | - |
| **Inbox Rate** | 88.4% | 67.9% | +20.5% |
| **Open Rate** | 31.2% | 18.7% | +12.5% |
| **Reply Rate** | 3.2% | 2.1% | +1.1% |
| **Positive Response** | 1.4% | 0.7% | +0.7% |
| **Meeting Booked** | 0.8% | 0.3% | +0.5% |

**ROI Impact:**
For 10,000 cold emails:

* **HTML:** 80 meetings booked
* **Plain-Text:** 30 meetings booked
* **Difference:** 167% more meetings with HTML

### Personalization Still Matters

**Important:** HTML format doesn't mean generic templates.

**Best Practice:**

* Use HTML for structure and branding
* Personalize content (name, company, pain points)
* Reference specific context
* Professional design + personal message = best results

**Example:**

```text theme={null}
✅ GOOD: Branded HTML email with:
   - Personalized greeting (first name)
   - Reference to recipient's company
   - Specific pain point mention
   - Clear, branded CTA
   - Professional signature with headshot

❌ BAD: Generic plain-text:
   "Hi there, I noticed your company..."
```

***

## Technical Analysis

### Spam Filter Behavior

We analyzed spam filter scoring across major providers:

#### Gmail's Spam Filter

**Plain-Text Penalties:**

* Generic greeting patterns: -5 points
* Common cold outreach phrases: -10 points
* No brand authentication: -8 points
* Similar to known spam: -12 points

**HTML Bonuses:**

* Professional HTML structure: +5 points
* Brand recognition (logo, colors): +8 points
* Proper email headers: +6 points
* Good engagement history: +10 points

#### Outlook's Junk Mail Filter

**Plain-Text Issues:**

* Matches phishing patterns: High risk
* No visual brand elements: Medium risk
* Generic structure: Medium risk

**HTML Advantages:**

* Branded design: Low risk
* Professional structure: Low risk
* Proper authentication: Low risk

### Machine Learning Insights

Modern email providers use ML models trained on:

* Billions of emails
* User engagement patterns
* Spam/legitimate classifications
* Report feedback

**What They Learned:**

1. Plain-text mass emails = mostly spam
2. Professional HTML = mostly legitimate
3. High engagement = inbox worthy
4. Quick deletion = spam folder

***

## Recommendations

### For Email Creators

<Check>**Use high-quality HTML** - Not plain-text, not generic templates</Check>
<Check>**Maintain brand consistency** - Professional design signals legitimacy</Check>
<Check>**Optimize for engagement** - Visual hierarchy, clear CTAs, scannability</Check>
<Check>**Test before sending** - Email Preflight across devices and clients</Check>
<Check>**Monitor metrics** - Track inbox placement, not just open rates</Check>

### For Cold Outreach

<Check>**Professional HTML template** - Branded design builds credibility</Check>
<Check>**Personalize content** - HTML structure + personal message</Check>
<Check>**Clear value proposition** - Use visual hierarchy to highlight benefits</Check>
<Check>**Legitimate sender signals** - Logo, company info, real signature</Check>
<Check>**Quality over quantity** - 100 inbox emails > 1000 spam folder emails</Check>

### For Email Platforms

<Check>**Generate clean HTML** - Follow email standards, not web standards</Check>
<Check>**Support dark mode** - Essential for modern deliverability</Check>
<Check>**Cross-client testing** - Ensure compatibility everywhere</Check>
<Check>**Optimize assets** - Compress images, clean code</Check>
<Check>**Educate users** - Explain why HTML outperforms plain-text</Check>

***

## How Migma Ensures Quality

### Clean Code Generation

Migma generates production-ready HTML that follows best practices:

**Technical Standards:**

* Battle-tested, cross-client rendering
* Semantic HTML structure
* Optimized inline CSS
* Email-safe elements only
* No bloated code

**Cross-Client Compatibility:**

* Works across 40+ email clients
* Mobile responsive by default
* Dark mode optimized
* Outlook-compatible layouts

**Deliverability Optimization:**

* CAN-SPAM compliant
* Proper unsubscribe headers
* Clean sender reputation signals
* Engagement-optimized design

### Testing & Validation

Email Preflight automatically checks:

* Spam score (target: `<5/10`)
* Link validation
* Image optimization
* Mobile responsiveness
* Dark mode rendering
* Cross-client compatibility

***

## Conclusion

The "plain-text is better for deliverability" myth is not only wrong—it's actively harming email performance.

### Key Takeaways

1. **High-quality HTML outperforms plain-text by 20.5% in inbox placement**
2. **Recipients spend 2.5x longer with HTML emails**
3. **HTML emails generate 2.6x higher click-through rates**
4. **Plain-text emails are 11x more likely to be marked as spam**
5. **Even for cold outreach, branded HTML performs better**

### The Bottom Line

Modern email deliverability is about **quality signals**:

**Plain-Text Signals:**

* ❌ Low effort (easy to generate at scale)
* ❌ Mass spam patterns
* ❌ Minimal engagement
* ❌ No brand authentication

**High-Quality HTML Signals:**

* ✅ Professional business
* ✅ Technical competence
* ✅ Better engagement
* ✅ Brand legitimacy

**Recommendation:** Use professionally designed, on-brand HTML for all email types—marketing, transactional, and even cold outreach.

***

## Related Resources

<CardGroup>
  <Card title="Best Practices Guide" icon="list-check" href="/advanced-features/email-deliverability-best-practices">
    How to optimize HTML emails for deliverability
  </Card>

  <Card title="Dark Mode Study" icon="moon" href="/case-studies/dark-mode-deliverability">
    How dark mode impacts inbox placement
  </Card>

  <Card title="Email Preflight" icon="flask" href="/email-editor/email-preflight">
    Test email quality before sending
  </Card>

  <Card title="FAQ: Deliverability" icon="circle-question" href="/faq#email-deliverability-&-technical">
    Common deliverability questions
  </Card>
</CardGroup>

***

## Study Details

**Conducted:** Q3-Q4 2024
**Sample Size:** 100,000+ emails
**Duration:** 6 months
**Industries:** B2B SaaS, E-commerce, Media, Professional Services
**Geographic Distribution:** North America (60%), Europe (30%), Asia-Pacific (10%)
**Email Clients Tested:** 40+ including Gmail, Outlook, Apple Mail, Yahoo, ProtonMail

For questions about this research, contact [research@migma.ai](mailto:research@migma.ai)


# Case Studies & Research
Source: https://docs.migma.ai/case-studies/overview

Migma's email generation technology is backed by rigorous research into email deliverability, user engagement, and inbox placement.

## Overview

Migma's email generation technology is backed by rigorous research into email deliverability, user engagement, and inbox placement. These case studies present our findings and demonstrate why Migma-generated emails consistently outperform alternatives.

<CardGroup>
  <Card title="Research-Driven" icon="microscope">
    100,000+ emails analyzed
  </Card>

  <Card title="Real-World Data" icon="chart-line">
    Actual inbox placement metrics
  </Card>

  <Card title="Multiple Industries" icon="building">
    B2B, E-commerce, SaaS, Media
  </Card>

  <Card title="Actionable Insights" icon="lightbulb">
    Practical recommendations
  </Card>
</CardGroup>

***

## Available Case Studies

<CardGroup>
  <Card title="Dark Mode & Email Deliverability" icon="moon" href="/case-studies/dark-mode-deliverability">
    **Key Finding:** Emails with proper dark mode support show 7.6% higher inbox placement rates.

    * 50,000+ emails analyzed
    * 60%+ of users prefer dark mode
    * 2x better engagement with dark mode optimization
    * Cross-client testing results

    **Learn more →**
  </Card>

  <Card title="HTML vs Plain-Text Deliverability" icon="code" href="/case-studies/html-vs-plaintext">
    **Key Finding:** High-quality HTML emails outperform plain-text by 20.5% in inbox placement.

    * 100,000+ emails tested
    * 6-month comprehensive study
    * B2B cold outreach analysis
    * Debunking the plain-text myth

    **Learn more →**
  </Card>
</CardGroup>

***

## Research Methodology

### Our Approach

All Migma case studies follow rigorous research standards:

<AccordionGroup>
  <Accordion title="Large Sample Sizes" icon="database">
    * Minimum 50,000 emails per study
    * Multiple industries and use cases
    * Diverse geographic distribution
    * Extended time periods (3-6 months)
  </Accordion>

  <Accordion title="Real-World Testing" icon="globe">
    * Actual email campaigns (not laboratory tests)
    * Multiple email service providers
    * Real recipient behavior tracking
    * Seed list testing for inbox placement
  </Accordion>

  <Accordion title="Controlled Variables" icon="sliders">
    * A/B testing methodology
    * Control groups for comparison
    * Isolated variable testing
    * Statistical significance validation
  </Accordion>

  <Accordion title="Comprehensive Metrics" icon="chart-mixed">
    * Inbox placement rates
    * User engagement (time, clicks, scrolls)
    * Spam complaint rates
    * Cross-client rendering quality
    * ROI impact measurement
  </Accordion>
</AccordionGroup>

### Email Clients Tested

Our research covers the full spectrum of email clients:

**Desktop:**

* Gmail (Web)
* Outlook.com
* Apple Mail (macOS)
* Outlook 2021/2019/2016 (Windows & Mac)
* Yahoo Mail
* ProtonMail
* Thunderbird

**Mobile:**

* Gmail App (iOS & Android)
* Apple Mail (iPhone & iPad)
* Outlook Mobile (iOS & Android)
* Samsung Email
* Yahoo Mobile

**Testing Methods:**

* Real device testing (not simulators)
* Seed list inbox placement tracking
* User behavior analytics
* Engagement metric tracking

***

## Key Insights

### 1. Dark Mode Is Critical

<Info>
  **60%+ of email users prefer dark mode.** Emails that break in dark mode signal low quality to both users and email providers.
</Info>

**Impact:**

* 7.6% higher inbox placement with dark mode support
* 2x better engagement (time spent, clicks)
* 4x fewer spam complaints

→ [Read Full Study](/case-studies/dark-mode-deliverability)

### 2. Quality HTML Outperforms Plain-Text

<Info>
  **The "plain-text is better" myth is wrong.** High-quality HTML emails achieve 20.5% higher inbox placement than plain-text.
</Info>

**Why:**

* Professional HTML signals legitimate business
* Better engagement metrics (2.5x more time spent)
* Plain-text associated with spam and low-effort outreach

→ [Read Full Study](/case-studies/html-vs-plaintext)

### 3. Email Quality Matters

**Not all HTML is equal.** The distinction between high-quality and low-quality HTML is significant:

| Quality Level | Inbox Placement | Engagement |
| - | - | - |
| **High-Quality HTML** | 92.3% | 24.3s avg time |
| **Low-Quality HTML** | 78.4% | 16.7s avg time |
| **Plain-Text** | 71.8% | 9.2s avg time |

**What makes HTML "high-quality":**

* Clean code structure (semantic HTML)
* Cross-client compatibility (40+ clients)
* Dark mode optimization
* Mobile responsive design
* Proper email standards (CAN-SPAM, GDPR)
* Optimized assets (compressed images, alt text)

***

## Practical Applications

### For Marketing Teams

<Check>**Optimize for dark mode** - Test every email in both light and dark modes</Check>
<Check>**Use professional HTML** - Don't rely on plain-text for "personalization"</Check>
<Check>**Test before sending** - Use Email Preflight to catch issues</Check>
<Check>**Monitor metrics** - Track inbox placement, not just open rates</Check>
<Check>**Invest in quality** - High-quality emails have measurable ROI</Check>

### For Cold Outreach

<Check>**Professional HTML templates** - Branded design builds credibility</Check>
<Check>**Personalize content** - HTML structure + personal message</Check>
<Check>**Quality over quantity** - 100 inbox emails > 1000 spam emails</Check>
<Check>**Track real metrics** - Measure inbox placement and reply rates</Check>

### For Email Platforms

<Check>**Generate clean HTML** - Follow email standards, not web standards</Check>
<Check>**Automatic dark mode** - Make it default, not optional</Check>
<Check>**Cross-client testing** - Ensure compatibility everywhere</Check>
<Check>**Educate users** - Explain why quality matters for deliverability</Check>

***

## How Migma Applies This Research

### Automatic Optimization

Every Migma-generated email benefits from our research:

**Dark Mode:**

* Automatic dark mode optimization
* Cross-client compatibility testing
* Smart color adaptation
* Layout preservation in both modes

**HTML Quality:**

* Clean, production-ready code generation
* Email-safe HTML and CSS
* Proper standards compliance
* Optimized assets automatically

**Deliverability:**

* Email Preflight testing (30+ devices)
* Spam score checking
* Link validation
* Mobile responsiveness verification

### Continuous Improvement

Our research informs product development:

* New features based on deliverability findings
* Testing across emerging email clients
* Adaptation to changing email provider algorithms
* Best practices integrated into AI generation

***

## Future Research

### Upcoming Studies

We're currently researching:

<CardGroup>
  <Card title="AI-Generated Images" icon="image">
    Impact of AI-generated vs stock images on engagement
  </Card>

  <Card title="Subject Line Optimization" icon="heading">
    ML-powered subject line testing for open rates
  </Card>

  <Card title="Personalization Scale" icon="user">
    Balancing personalization with automation
  </Card>

  <Card title="International Deliverability" icon="globe">
    Regional differences in email provider behavior
  </Card>
</CardGroup>

### Research Partnership

Interested in collaborating on email deliverability research?

<CardGroup>
  <Card title="Partner With Us" icon="handshake" href="mailto:research@migma.ai">
    Conduct joint research studies
  </Card>

  <Card title="Share Your Data" icon="chart-line" href="mailto:research@migma.ai">
    Contribute to future case studies
  </Card>
</CardGroup>

***

## Related Resources

<CardGroup>
  <Card title="Best Practices Guide" icon="list-check" href="/advanced-features/email-deliverability-best-practices">
    Apply research findings to your emails
  </Card>

  <Card title="Email Preflight" icon="flask" href="/email-editor/email-preflight">
    Test emails based on our research
  </Card>

  <Card title="FAQ: Deliverability" icon="circle-question" href="/faq#email-deliverability-&-technical">
    Common questions about our findings
  </Card>

  <Card title="Creating Emails" icon="wand-magic-sparkles" href="/creating-emails/overview">
    Generate optimized emails with Migma
  </Card>
</CardGroup>

***

## Contact

For questions about our research or to discuss collaboration:

**Research Team:** [research@migma.ai](mailto:research@migma.ai)

**Press Inquiries:** [press@migma.ai](mailto:press@migma.ai)

**General Support:** [support@migma.ai](mailto:support@migma.ai)

***

## Disclaimer

All research presented represents findings from our specific testing conditions and sample sizes. Results may vary based on industry, audience, sending infrastructure, and other factors. We encourage users to test and validate findings within their own context.


# Migma Product Changelog
Source: https://docs.migma.ai/changelog

Follow the Migma product changelog for new email creation, sending, audience, integration, API, agent, collaboration, and deliverability features.

The latest Migma releases, newest first. Each update covers what shipped and why it matters.

<Tip>
  Every release also has its own page, grouped by month in the left sidebar. The Migma RSS feed is available for changelog updates.
</Tip>

<Update label="September 2026" description="Connected agents save references and set brand rules, MCP clients connect without registering first, native app redirect schemes, Grok Bot claim-code connection">
  ## Connected agents keep your brand on track (September 5th)

  An agent connected to Migma over MCP now behaves like your email person from the first message. After connecting it reads your setup (brand kit, saved references, audience, sending domain) and proposes the one next step instead of listing features.

  Two new tools back that up. **Save reference** stars one of your emails or stores a design you paste so future emails match it. **Update brand guidelines** writes a lasting rule (a tone, a layout habit, an image style) into the brand so every future email follows it. Migma keeps a snapshot of the previous rules before each change. The same capabilities are available in the public API and the Node SDK.

  [Agent setup](/agent-setup) · [Grok Bot](/grok)

  ## MCP clients connect without registering first (September 3rd)

  Improves how AI clients connect to Migma over MCP. A client no longer has to register itself before the browser approval, and native apps can return to their own app scheme (for example `cursor://` or `com.example.app:/callback`) after you select **Allow**. The approval page shows the exact place the connection returns to, and the security model is unchanged: you still sign in, review the permissions, and allow the connection yourself.

  Grok Bot connects through Migma's claim-code flow with a single approval link, since its cloud computer cannot receive a browser callback.

  [Agent authentication](/agent-auth) · [Grok Bot](/grok)
</Update>

<Update label="August 2026" description="Column layouts and image captions in the Visual Editor, image region effects, HTML import for agents, billing credits and domain purchase for agents, send one campaign to several segments or lists, clearer sending limits, main-domain sending, custom DNS records and forwarding, all-brands managers can run sending domains and People, point at a section of an email, faster MCP drafts and CSV import, brand facts from MCP, Klaviyo editor adapt, one-prompt agent setup, PNG export, MCP email previews, CLI and agent browser sign-in">
  ## Add columns in the Visual Editor (August 31st)

  Adds a **Columns** group to the **Add block** menu in the Visual Editor. Choose **2 columns**, **3 columns**, **1/3 + 2/3**, or **2×2 grid** to place a side by side layout, then fill each cell with text, an image, or a button. Columns stack on narrow screens, so the email still reads on a phone.

  [Visual Email Editor](/email-editor/visual-editor)

  ## Image captions in the Visual Editor (August 31st)

  Adds **Add caption** to the image toolbar in the Visual Editor. Select an image and choose **Add caption** to place a small line of text under it, then click it to write your own. The caption uses your brand's font and colors like any other text.

  [Visual Email Editor](/email-editor/visual-editor)

  ## Highlight or cover part of an image (August 30th)

  Adds **Effects** to **Adjust image** in the Visual Editor. Use **Spotlight** to keep one rectangle or oval clear while dimming the rest of the image. Use **Cover area** to tint or hide one selected area. Drag the area or its corners to adjust it, then choose the overlay color and strength.

  [Visual Email Editor](/email-editor/visual-editor)

  ## Ready Migma addresses without warmup (August 25th)

  Updates managed Migma addresses to use their fixed daily limit without Domain Warming. Eligible new accounts can receive a ready address after email verification. Connect a domain you own when you need separate sending reputation and higher limits.

  [Sending Domains](/sending-domains/overview) · [Domain warming](/sending-domains/domain-warming)

  ## Send to several segments or lists (August 24th)

  Adds multi-select on campaign Recipients and Publish for Migma sending. Pick several segments, or several lists, in one campaign. People who appear in more than one still get a single email. You cannot mix segments and lists. A selection with no eligible people still blocks send.

  [Send Campaign](/campaigns/send-campaign)

  ## Agents can convert existing HTML emails (August 23rd)

  Adds HTML import for agents. Convert an existing HTML email or a saved `.eml` into an editable Migma email, the same way as **HTML to Email** on Create. One import can make a series. Each email is a canvas slot with its own emailId and canvas link.

  [HTML to Email](/creating-emails/html-import) · [MCP Server](/mcp-server)

  ## Agents can check credits, upgrade, and buy domains (August 20th)

  Adds billing and domain purchase to the API and the Migma MCP server. Agents can check the current plan and remaining credits, get a Stripe checkout or billing portal link to upgrade, and search, buy, and track domains until registration is active. Domains renew yearly, and failed registrations are refunded automatically. Agents can also add and remove DNS records on domains bought in Migma; email sending records stay protected. Adds `billing:read` and `billing:write` API key scopes. Payment always happens in the user's browser via Stripe.

  [MCP Server](/mcp-server) · [API reference](/api-reference/introduction) · [Agent Auth Reference](/agent-auth)

  ## Clearer sending limits (August 20th)

  Improves Campaigns when you reach today's or this month's sending limit. You can still prepare a campaign. Before send or schedule, Migma says whether to wait, send what is left today, or increase limits. A campaign that is paused at the limit now says **Waiting**.

  [Send Campaign](/campaigns/send-campaign)

  ## Send from your main domain (August 19th)

  Adds your main domain as the campaign sender, so recipients see `news@yourbrand.com` with no subdomain. Receipts and password resets stay on `notify.yourbrand.com`, so a rough campaign cannot take them down. New domains include both addresses in the DNS records shown at setup. A domain you connected earlier that still has `send.yourbrand.com` keeps that address as a marketing sender.

  [Sending Domains](/sending-domains/overview)

  ## DNS records and forwarding for domains bought in Migma (August 19th)

  Adds **Custom DNS records** and **Domain forwarding** to the DNS records tab for domains bought in Migma. Add and remove A, AAAA, CNAME, MX, TXT, and NS records at any name under your domain. Verify the domain with another service, receive email through your inbox provider, point a subdomain at your own server, or delegate one elsewhere. You can also change where visitors land when they open your domain. Records that keep email authenticated, like SPF, DKIM, and DMARC, stay with Migma.

  [Buy a Domain](/sending-domains/buy-domain)

  ## Managers on all brands can run the account (August 19th)

  Updates **Manager** on **All brands** so they can manage sending domains, People, invites, seats, and API keys. Paid seat or free collaborator does not matter. A manager on one brand still only runs that brand. Plan and billing stay with the workspace owner.

  [Team access](/collaboration/team-access) · [Sending domains](/sending-domains/overview)

  ## Point at a section of an email (August 17th)

  Adds **Mark Select** in the message box, next to the visual editor. Drag a box over part of an email, like a footer, a header, or one block, then say what to do with it: "use this footer everywhere" or "make this smaller". The section you marked stays attached to your next message so edits land exactly where you pointed. It works on references pinned to your canvas too, so you can mark a competitor email and ask for your own version of that part.

  [Visual canvas](/creating-emails/visual-canvas)

  ## Faster CSV import and draft previews from MCP (August 17th)

  Agents connected to Migma MCP can import a contact CSV in one step, with optional list tags and automatic column matching for common headers. After generating emails, agents show preview images and canvas links first, and only run inbox checks when you ask or before a send.

  [MCP Server](/mcp-server) · [Manage contacts](/audience/manage-contacts) · [ChatGPT](/agents/mcp-chatgpt)

  ## Save brand facts from MCP (August 17th)

  Agents connected to Migma MCP can add and list knowledge-base entries for a brand. Lasting facts like tone, products, offers, and policies improve later email generation.

  [MCP Server](/mcp-server)

  ## Adapt emails for Klaviyo's editor (August 16th)

  Adds **Adapt for Klaviyo editor** on the Klaviyo export panel. Migma prepares a simpler version if needed, creates the template in Klaviyo, and shows **Open in Klaviyo** the same way HTML export does. The canvas email stays unchanged. **Create HTML template** still sends the original layout.

  [Klaviyo](/integrations/klaviyo)

  ## One-prompt agent setup (August 16th)

  Adds an [Agent Setup](/agent-setup) page. Paste one line into Claude Code, Codex, Cursor, or any AI coding agent, and the agent installs Migma skills, the CLI, and the MCP server itself.

  [Agent Setup](/agent-setup) · [Setup](/setup)

  ## Export emails as PNG (August 14th)

  Adds PNG image export for coding agents and the API. Export a generated email as an image from Publish, MCP, the SDK, or `migma export png`.

  Removes MJML export. Use HTML, PNG, or PDF instead.

  [Export options](/email-editor/export-options) · [MCP Server](/mcp-server)

  ## Agents can see email previews (August 13th)

  Adds preview images when a coding agent lists, opens, or finishes generating emails through MCP. Agents can also pass reference images or an existing email when generating.

  Improves those same tools so they return a canvas link and skip full HTML unless asked. Validation accepts an email id instead of raw markup. Brand list is compact and searchable.

  [MCP Server](/mcp-server)

  ## CLI and agents sign in without pasting a key (August 13th)

  Adds browser sign-in for `migma login` and the same start path for coding agents: connect hosted MCP, run `migma login`, or approve a claim code. List and get MCP tools are available as soon as you are signed in.

  [CLI](/cli) · [MCP Server](/mcp-server) · [Agent registration](/agent-registration)
</Update>

<Update label="July 2026" description="Sending metrics and campaign notifications, content renaming, deeper brand import, Founder Pass, comment threads, campaign click maps, calendar prepared campaigns, Migma for Telegram, events and conversion tracking, provider contact imports, brand settings redesign, MCP OAuth, audience insights, bulk contact imports">
  ## Sending Metrics and Campaign Notifications (July 19th)

  Adds account-level sending metrics to the Migma API. Review current-month sent, delivered, bounced, and complained totals; today's sent and reserved usage; daily and monthly limits; remaining capacity; and up to 12 previous months.

  Adds campaign notifications in Slack and Telegram. Tell Migma in the current channel or chat to notify you about campaigns. Migma posts when sending starts, when a campaign is sent, or if it fails, then follows a successful send with a stats digest about 30 minutes later.

  Adds next-campaign planning in Slack and Telegram. Ask what to send next and Migma answers from your Marketing Calendar: prepared campaigns with their reasons and proposed send times, plus upcoming moments worth covering. Confirm a prepared campaign in chat and Migma schedules it.

  [Slack](/integrations/slack) · [Telegram](/integrations/telegram) · [API reference](/api-reference/introduction)

  ## Rename campaigns, chats, series, and emails (July 18th)

  Adds **Rename** to campaign, chat, series, and individual email menus. Campaign names can be changed before or after sending, while individual emails keep their original subject.

  A chat and its series share one name, so renaming either keeps both labels aligned.

  [Visual Canvas](/creating-emails/visual-canvas) · [Campaigns](/campaigns/overview)

  ## Deeper Brand Import (July 16th)

  Improves **Brand Import**: Migma now studies relevant About, product, pricing, news, and contact pages in addition to the homepage. It learns the brand's products, positioning, copy and CTA patterns, footer details, social links, and observed icon or emoji style.

  Useful findings appear in **Brand Guidelines** and guide future email design and copy. Recent public brand and industry updates are kept in one dated research entry, while anything you add manually stays untouched.

  [Configure your brand](/get-started/configure-brand)

  ## Founder Pass for Product Hunt (July 11th)

  Updates the limited **Founder Pass** with a direct Premium overview: up to 200,000 monthly sends for marketing and transactional email, API and hosted MCP access, analytics, and Slack and Telegram beta access.

  Eligible new customers create an account, start a seven-day trial, then continue into setup. The first 200 keep the \$49 monthly Founder price while the qualifying subscription stays active.

  [Claim Founder Pass](https://migma.ai/founder-pass)

  ## Comment threads on canvas (July 11th)

  Adds anchored comment threads to **Visual Canvas**. Place a comment beside an email, mention a teammate with `@`, reply in the thread, and resolve or reopen feedback without covering the canvas with sticky notes. Mention alerts open the exact thread and wait for teammates who are away. Comment markers show who started each thread and how many replies it contains.

  Commenters can now create, reply to, move, and resolve canvas comments while email editing and sending stay disabled for their role. Unresolved feedback remains available to Migma during the next design turn. Resolved threads stay on canvas for reference without affecting later edits.

  [Visual Canvas](/creating-emails/visual-canvas) · [Real-time collaboration](/collaboration/realtime) · [Team access](/collaboration/team-access)

  ## Click map for campaign emails (July 9th)

  Adds **Click map** to each campaign's **Analytics** tab. See recorded human clicks directly on links and buttons in the sent email, with stronger intensity for actions clicked by more people. Select a marker to see its total clicks.

  Bot and scanner activity stays hidden, along with system actions such as unsubscribe and preference links. The map shows which email action was clicked; email clients do not provide cursor coordinates.

  [Track results](/campaigns/track-results)

  ## Marketing Calendar Prepares Your Campaigns (July 6th)

  Improves the **Marketing Calendar**: Migma now prepares upcoming calendar campaigns before you ask. Each item under **Prepared for you** is a finished email with a suggested audience and send time. Review it, click **Approve**, and the campaign is scheduled. Dismiss anything that does not fit.

  Adds **Connect calendar**: link Google Calendar (read only) and real business events like launches and sales become planned emails anchored to their true dates.

  Improves performance learning: recent sent campaigns now appear as subdued items on their calendar dates. Open one to see click and open rates. Migma uses delivered-weighted human clicks as the main timing signal and treats opens as supporting context.

  Adds **Calendar settings**: turn on automatic email creation from your calendar (works with or without a connected calendar) and Migma prepares upcoming emails in the background, then emails you when they are ready, like "Your Black Friday email is ready to approve", with review links. Notifications have their own toggle. Migma skips anything you already created yourself, and you approve each email before it sends.

  [Marketing Calendar](/campaigns/marketing-calendar) · [Send a Campaign](/campaigns/send-campaign)

  ## Migma for Telegram (July 6th)

  Adds **Migma for Telegram**, so you can create and edit branded emails from a Telegram chat or a group. Start a chat with the bot, connect your account once with the Telegram Login Widget, then ask it to list your brands, import a brand from a URL, generate emails, edit them, or find design inspiration. Attach an image to generate an email from it.

  Connecting uses Telegram's verified Login Widget, so your identity is asserted by Telegram and nothing is pasted. The bot creates and edits drafts only. Sending, scheduling, and exporting stay in Migma, where you review and approve the send.

  [Telegram](/integrations/telegram) · [Agent auth](/agent-auth)

  ## Import Contacts from Mailchimp, Klaviyo, and HubSpot (July 3rd)

  Adds **Import from integration** to the **Add Contact** menu on the Contacts page. Choose a connected Mailchimp audience, saved segment, or tag, a Klaviyo list or segment, or a HubSpot contact list, and Migma imports the contacts as a background job with progress and final counts in **Import History**.

  Consent stays intact: by default only subscribed contacts are imported, contacts without clear marketing permission stay non-sendable, and existing unsubscribed or bounced contacts are never resubscribed. Every import creates a source tag and a matching snapshot segment, so the imported audience is ready to target right away.

  [Mailchimp](/integrations/mailchimp) · [Klaviyo](/integrations/klaviyo) · [HubSpot](/integrations/hubspot) · [Manage contacts](/audience/manage-contacts)

  ## Brand Settings Redesign (July 3rd)

  Improves brand settings: sections now follow how an email reads, and a new **Visual Identity** section groups **Logos**, **Colors & Styling**, and **Typography** in one place. **Knowledge Base** is now **Brand Guidelines**, with generation rules in their own **AI Instructions** section. The **Gallery** now holds brand images only, and **Company Profile** and **Sitemap** sit together under **Footer**, where social links are managed.

  Adds a **Search settings** box to the settings sidebar. Press slash to focus it, then search by setting name or by what lives inside a section, including connected tool names like Notion or Stripe.

  [Brand setup](/get-started/configure-brand) · [External MCP servers](/integrations/mcp-servers)

  ## Events and Conversion Tracking API (July 3rd)

  Adds `POST /v1/events` and `/v1/events/batch` so your backend can report customer events like purchases, trials, and refunds. Send a single event with an **Idempotency-Key** header, or batch up to 500 events with per-row dedupe keys and row-level partial success.

  An event that carries an order identifier and a numeric value is recorded as a conversion and attributed to the last email the recipient clicked within the previous five days, credited once. Event names containing refund or cancelled record negative amounts, so returned revenue is subtracted instead of counted.

  Conversions and revenue then appear in campaign stats, shown only when real activity has been reported so a campaign with no attributed revenue shows no figures rather than fake zeros. Events never change subscription status.

  [Events](/events) · [API reference](/api-reference/introduction)

  ## MCP Clients Connect with OAuth (July 2nd)

  Adds OAuth connection for hosted MCP clients that support it, including claude.ai custom connectors. Add `https://migma.ai/mcp`, sign in, review scopes on the Migma consent page, and approve. Migma gives the client a scoped key automatically, so no API-key pasting is needed.

  Manual bearer-key setup remains supported. Sending access is shown as `email:send` on consent, and generated keys can be revoked from **Settings → Developers → API Keys**.

  [MCP](/mcp-server) · [Agent auth](/agent-auth)

  ## Audience Insights in Email Analytics (July 2nd)

  Adds device, email client, top clicked link, and inbox provider breakdowns to the **Activity** page, covering every send in the selected date range. Inbox provider open rates for Gmail, Outlook, Yahoo, and Apple sit side by side, making it easy to spot a provider filtering your mail before it affects a whole campaign. **Top links** ranks the links and buttons in your emails by clicks.

  Each campaign's **Analytics** tab shows the same breakdowns scoped to that campaign. Engagement counts exclude bot and scanner activity, and the card notes where Apple's Mail Privacy Protection inflates opens.

  [Send campaigns](/campaigns/send-campaign) · [Domain metrics](/sending-domains/metrics)

  ## Bulk Contact Imports (July 1st)

  Adds bulk contact import from a CSV in the dashboard and through the API, SDK, CLI, and MCP server. Large lists upload and process in the background, columns map to contact fields automatically, and **Import History** shows a live breakdown of contacts created, updated, skipped, and failed.

  Adds suggested segments after an import, so a fresh list becomes a targeted audience in one step. Choose to update or skip contacts that already exist.

  [Manage contacts](/audience/manage-contacts) · [API reference](/api-reference/introduction) · [SDK](/sdk) · [CLI](/cli) · [MCP](/mcp-server)
</Update>

<Update label="June 2026" description="Remote MCP, Omnisend export, and AI-native ESP updates">
  ## Draft-Only API Key Permissions (June 30th)

  Adds `email:write` for creating and editing generated emails without granting send access. API keys and agent registrations can now let tools prepare drafts while keeping test and live sends behind `email:send`.

  Updates brand import and retry permissions to use `project:write`, matching the permissions shown in **Settings → Developers**.

  [Authentication](/authentication) · [Agent registration](/agent-registration)

  ## Duplicate Emails and Series (June 29th)

  Adds **Duplicate email** and **Duplicate series** to the email card menu. Duplicate opens the latest canvas version in a new chat, so you can try another direction without changing the original.

  [Visual canvas](/creating-emails/visual-canvas) · [Email series](/creating-emails/email-series)

  ## Email Metrics and Domain Warmup (June 28th)

  Adds per-email performance to the app, API, SDK, CLI, and MCP server. Open a generated email's metrics to review delivery, opens, clicks, period deltas, campaign usage, transactional send logs, top locations, preflight status, and improvement options across every send of it.

  Adds **Copy for AI** to Publish and API setup surfaces, so coding agents can wire a selected Migma email into an app with a short setup prompt.

  Improves **Domain Warming** with starting volume, daily growth, and safety settings before warmup starts. The Warming tab now shows today's cap, safe remaining capacity, the next cap, a schedule preview, and bounce and complaint thresholds.

  Paused warmup now turns off warmup caps until you resume. Automatic safety pauses still protect risky domains.

  [API reference](/api-reference/introduction) · [SDK](/sdk) · [CLI](/cli) · [MCP](/mcp-server) · [Domain warming](/sending-domains/domain-warming)

  ## API, Sender, and Agent Updates (June 27th)

  Adds batch contact deletion to the API. Remove many contacts by email in one request, and see which emails had no matching contact.

  Adds From addresses to Sending Domains. Manage each domain's sender names and addresses, set the default sender, and keep Publish using the same verified sender list.

  Adds safe retries for write requests. Retry after a network error or timeout and Migma replays the original result instead of doing the work twice. The official SDK carries the retry key automatically.

  Adds campaign performance to the API, SDK, CLI, and MCP server. Read opens, clicks, bounces, unsubscribes, and per-recipient delivery activity for any campaign.

  Adds MCP capabilities and guided workflows. Your agent can ask what Migma can do, then follow recipes to design an email, send a test, launch a campaign, and read results.

  Adds domain security to Sending Domains. If another team is using a domain you own, you can prove DNS ownership and claim it back to your workspace. Migma re-provisions the domain and prepares it for sending under your account.

  Adds bot protection to public forms. Signup, login, password reset, waitlist, and careers forms now verify you are human before submitting.

  Adds a redirect URL option when buying a domain. The domain apex can point to your brand site while you set up sending.

  [Sending domains](/sending-domains/overview) · [Contacts API](/api-reference/introduction) · [MCP](/mcp-server) · [Bring your agent](/agent-auth)

  ## Remote MCP for AI Tools (June 24th)

  Adds remote MCP support so teams can connect Migma to MCP-compatible AI tools without running a local server. Once connected, agents can help create, send, validate, and export emails from the tools your team already uses.

  Local setup remains available for teams that prefer it.

  [MCP](/mcp-server)

  ## Omnisend Export

  Adds Omnisend as an OAuth export destination from **Publish**. Connect a brand, export a draft campaign to Omnisend, or keep using HTML export when you want to import manually.

  [Export options](/email-editor/export-options)

  Email has an agent now. Connect your brand, set a goal, and Migma turns it into production-ready email marketing. This is the biggest release yet: Migma is no longer just an AI email creator. It is now an AI-native ESP that helps teams create, segment, collaborate on, render, send, export, and improve email sequences from one workspace.

  ## Email Canvas: Full Sequences, Not Single Emails (June 22nd)

  You can now generate complete email sequences inside one canvas instead of designing one email at a time. Welcome, onboarding, product launch, abandoned cart, win-back, lifecycle, and transactional sequences are all generated from a single prompt. Every email in the sequence can be edited, rewritten, localized, personalized, and improved in the same workflow, so teams can shape the full customer journey instead of building isolated emails.

  [Email series](/creating-emails/email-series) · [Visual canvas](/creating-emails/visual-canvas)

  ## Email Rendering Built for Inboxes

  Migma now produces email-safe output for major inboxes, including Gmail, Outlook, Apple Mail, mobile, dark mode, light mode, and older clients. Designs should hold up when subscribers open them, not only inside the editor.

  [Client compatibility](/email-editor/client-compatibility) · [Email preflight](/email-editor/email-preflight)

  ## AI Segmentation: The Right Email for the Right Segment

  Migma now helps decide who should receive what. Create audience segments with AI, generate campaign variants for different customer groups, and personalize by language, country, persona, and audience context. A normal email designer creates one email; Migma creates the right email for the right segment, so each cohort gets a message that actually fits it.

  [Manage contacts](/audience/manage-contacts) · [Tags and segments](/audience/manage-tags-and-segments) · [Engagement segments](/audience/engagement-segments)

  ## Workspaces and Realtime Collaboration

  Email marketing is team work for founders, marketers, designers, agencies, clients, and operators. Migma now supports invites, seats, workspaces, comments, realtime editing, and campaign review in one canvas.

  [Real-time collaboration](/collaboration/realtime) · [Workspaces](/collaboration/workspaces) · [Team access](/collaboration/team-access) · [Seats](/collaboration/seats)

  ## Agentic Handoff: Start From the Tools Your Team Already Uses

  Migma can now work from the AI tools your team already uses, including Claude, Cursor, Lovable, Figma, screenshots, HTML, your website, files, references, and prompts. Agents can bring plans and source material into Migma, where teams can render, send, and export the emails.

  [MCP servers](/integrations/mcp-servers) · [Setup skill](/setup) · [CLI](/cli) · [Design with Claude](/creating-emails/claude-design)

  ## Send and Export Through Your Stack

  Teams can adopt Migma without rebuilding their entire email stack on day one. Send or export through Mailchimp, HubSpot, Klaviyo, and similar tools, and prepare marketing emails, transactional emails, brand and domain setup, and sending workflows from one place. Migma fits into the pipeline you already run instead of asking you to replace it.

  [Mailchimp](/integrations/mailchimp) · [Klaviyo](/integrations/klaviyo) · [Email service providers](/integrations/email-service-providers) · [Sending domains](/sending-domains/overview)

  ## References, Files, Screenshots, Voice, and HTML Input

  Real teams start with context. Migma can use files, screenshots, pasted HTML, design references, competitor examples, comments, and voice input. The more context you bring, the closer the first draft lands.

  [HTML import](/creating-emails/html-import) · [Figma import](/creating-emails/figma-import) · [Image clone](/creating-emails/image-clone) · [Prompt-based creation](/creating-emails/prompt-based-creation)

  ## Performance Feedback Loop

  Migma is moving from creation to optimization. Campaign feedback can guide future sends so teams create better messages over time.

  [Domain metrics](/sending-domains/metrics)

  ## Build a Segment From Someone You Already Know (June 20th)

  <Frame>
    <img alt="Create New Segment dialog with the describe-in-words search box and filter rows" />
  </Frame>

  The plain-language segment box in **Contacts** now understands examples. Ask for "contacts like [alex@acme.com](mailto:alex@acme.com)" or "subscribers similar to my best customer" and Migma looks up that person, finds the traits that make them stand out from the rest of your audience, and drafts a lookalike segment from those. It skips traits almost everyone shares, and never targets on names or email addresses, so you get a real audience rather than a copy of one contact.

  Plain-language drafting also reads attributes and engagement together, so requests like "pro plan contacts in France who opened recently" become filters you can review before saving. New **Try** chips under the box give you a starting phrase to edit.

  You can also point engagement filters at one campaign, for example "people who received the launch but did not click it". Migma reads the campaign recipient log and tells you clearly when that activity is no longer retained.

  ## Group contacts by a value pattern

  Ask for a group like "investors" and Migma looks at the real values in your contacts to find what they share, for example emails that end in ".vc", then writes one rule instead of listing every address. Because it is a rule, the segment keeps matching new contacts as they arrive. When you build filters by hand, field conditions now offer **starts with**, **ends with**, **contains**, and **does not contain** alongside the exact **is** and **is not**.

  Improves field conditions for imported numeric and date values. Counts, prices, scores, and dates now appear as typed properties with matching operators, and plain-language drafting can suggest thresholds from real audience values.

  [Tags and segments](/audience/manage-tags-and-segments) · [Engagement segments](/audience/engagement-segments)

  ## Agents and Teammates Show Up Live (June 17th)

  Presence, member avatars, and agent activity are now clearer while teams work together on canvas. You can see who is editing, where their focus is, and when an agent is generating, so collaboration feels coordinated instead of accidental.

  [Real-time collaboration](/collaboration/realtime)

  ## Turn Searches and Imports Into Segments

  Describe an audience in plain language, preview the matching contacts, and save the result as an AI-built segment after importing subscribers. The flow turns ad-hoc searches and fresh imports into reusable segments without leaving Contacts.

  [Manage contacts](/audience/manage-contacts) · [Tags and segments](/audience/manage-tags-and-segments)

  ## Protect Accounts With 2FA

  Two-factor authentication is now available account-wide. Use an authenticator app or emailed security codes, verify your email address, and download backup codes from Settings so you can recover access if you lose your device.

  ## Set Up Migma From Create

  A new **Set up Migma** action on Create copies `/setup` instructions so coding agents can audit your app, create emails, and wire safe backend sends. It hands your agent everything it needs to integrate Migma correctly the first time.

  [Setup skill](/setup)

  ## Create a Full Email Series in Under a Minute

  Generate connected welcome, launch, nurture, and winback flows from a single prompt. Instead of building each message by hand, you describe the goal and Migma drafts the whole series ready to refine.

  [Email series](/creating-emails/email-series)

  ## Realtime Collaboration and Workspaces

  Share workspaces, invite teammates, and build emails together live. The whole team can work on the same canvas at once, so reviews and edits happen in place.

  [Real-time collaboration](/collaboration/realtime) · [Team access](/collaboration/team-access)

  ## Agents Register Themselves (June 13th)

  Agents can now register themselves with scoped API keys. An AI agent like Claude, Cursor, or OpenClaw asks to connect, you approve it with a short code at [migma.ai/claim](https://migma.ai/claim), and the agent receives its own scoped API key. You never create, copy, or paste a key. You see the agent's name and the permissions it requested before you confirm, and you can revoke any agent key from Settings, Developers, API Keys. Migma follows the open [auth.md](https://workos.com/auth-md/docs) convention, so agents discover and complete the whole flow on their own.

  [Agent registration](/agent-registration)

  ## Account Security (June 12th)

  Two-factor authentication is now available from Settings. Use an authenticator app or emailed security codes, verify your email address, and download backup codes for account recovery, so your workspace stays protected even if a password leaks.

  ## Smart Segmentation

  Contacts now supports natural-language segment drafting. Describe an audience like "inactive subscribers in Spain" and Migma builds the matching filters for you. Contact search also gains smart filtering, custom-field filters, activity filters, live counts, and post-import segment suggestions, so targeting is faster and far less manual.

  [Manage contacts](/audience/manage-contacts) · [Tags and segments](/audience/manage-tags-and-segments)

  ## Setup Skill

  A new **Set up Migma** action on Create copies `/setup` instructions with sender status, agent auth guidance, and skill or plugin install paths. Coding agents use it to audit the app, create emails, and wire safe backend sends without guesswork.

  ## Live Collaboration Polish

  Shared workspace presence is clearer, with more legible member and agent activity while teams work on canvas. It is easier to tell at a glance who is doing what.

  [Real-time collaboration](/collaboration/realtime)

  ## Free Collaborators (June 10th)

  Migma now offers a seat-free way to invite editors and managers. Owners and admins check **Free collaborator** when inviting from a brand's Share panel or from Settings, People & Access. Free collaborators edit and collaborate in real time without using a seat, and AI generation runs on their own plan's credits. People they invite stay seat-free automatically, so teams and agencies can scale collaboration without scaling seat costs.

  [Seats](/collaboration/seats)

  ## Agencies and Client Brands (June 7th)

  New guidance helps agencies run client work cleanly. Keep each client in its own workspace with your team as editors, or join a client's brand as a guest. Editors use a seat, reviewers stay free, and the workspace owner is billed, so the billing and access model matches how agency engagements actually work.

  [Agencies & client brands](/collaboration/agencies)

  ## Proprietary Email Engine (June 4th)

  Migma's email rendering engine now powers output. Emails render to table-based HTML for Outlook, webmail, and mobile, and preflight adds client previews before send so you can catch rendering issues before subscribers do.

  [Client compatibility](/email-editor/client-compatibility)

  ## Image Generation Toggle

  A per-project toggle now controls the image and GIF generator, so you can turn generated imagery on or off depending on the brand or workflow.

  [AI image generation](/content-hub/ai-image-generation)

  ## Campaign Publishing Dialog (June 1st)

  The publishing dialog is redesigned for send, export, and API options, with clearer tabs, better recipient copy, refined typography, and improved preview controls. Choosing how a campaign goes out is now faster to understand at a glance.

  ## Voice Dictation in Composer (June 1st)

  The prompt bar now has a mic control. Speech transcribes directly into the composer for both single emails and series briefs, so you can describe what you want out loud instead of typing it.
</Update>

<Update label="May 2026" description="Real-time collaboration, the visual canvas, email series, email-safe rendering, and deliverability controls">
  ## Import Paths Render to Email-Safe HTML (May 31st)

  Prompt, Figma, image, HTML, and Claude design imports now all render to the same table-based HTML for Outlook, Gmail, Apple Mail, and mobile. However you bring a design into Migma, it ends up as email that behaves consistently in the inbox.

  ## Claude Design Import

  You can now import Claude design exports as editable Migma emails, turning agent-generated designs into something you can refine and send.

  [Claude design](/creating-emails/claude-design)

  ## HTML Import

  Paste or upload external HTML and Migma converts legacy templates into compatible Migma email, so existing assets can move into the workflow without a rebuild.

  [HTML import](/creating-emails/html-import)

  ## Figma and Image Import

  Figma frame conversion is improved for layout, spacing, and typography, and screenshot and mockup conversion lands closer to the source for higher fidelity from the start.

  [Figma import](/creating-emails/figma-import) · [Image clone](/creating-emails/image-clone)

  ## Client Compatibility

  All creation and import paths render to table-based HTML, including desktop Outlook (Word rendering). Migma sets `color-scheme` and optional locked brand colors, and preflight reports pass, warning, or fail per client so you know exactly how an email will land before sending.

  [Client compatibility](/email-editor/client-compatibility)

  ## Collaboration, Canvas, and Email Series (May 31st)

  Migma now supports real-time team editing on a shared visual canvas alongside multi-email series workflows. Teams can plan, draft, and refine entire sequences together in one space.

  ## Team Access

  Projects now have roles — Manager, Editor, Commenter, and Viewer — plus account-level invites that apply across all projects. Manage members and pending invites from project settings.

  [Team access](/collaboration/team-access)

  ## Real-Time Collaboration

  Collaboration gains presence avatars, live cursors and focus, canvas sync, and a generating indicator that shows when another member is running generation, so the whole team stays in sync as they work.

  [Real-time collaboration](/collaboration/realtime)

  ## Visual Canvas

  A new spatial board holds emails, social posts, and blog nodes in one place. Pin HTML references, images, URLs, and competitor emails, and use sticky notes, flow lines, groups, and canvas version restore to plan campaigns visually.

  [Visual canvas](/creating-emails/visual-canvas)

  ## Email Series

  Generate a multi-email series from one brief, then add, remove, or reorder emails. Batch edit across the series, set per-email cadence, and restore prior versions per email — the full sequence is editable, not locked.

  [Email series](/creating-emails/email-series)

  ## Deliverability Settings (May 5th)

  A new **Settings, Email, Deliverability** area gives you more control over who you send to and how list health is maintained:

  * **Exclude risky addresses**: an optional toggle skips disposable and role addresses on send, and skipped campaigns list the reason `risky`.
  * **Daily re-validation**: a nightly re-check for subscribed contacts whose validation is older than 30 days.
  * **Segment validation filter**: scope segments by `valid`, `invalid`, `risky`, or `unknown`, and contact detail now shows **Last validated**.

  [Deliverability](/audience/deliverability)

  ## Skipped Recipients Per Campaign (May 4th)

  A new **Skipped** sub-tab sits under campaign **Recipients** next to **Sent**, listing pre-send exclusions with their reason. Filter by reason and open the contact directly from a row to understand exactly why someone did not receive a campaign.

  [Skipped recipients](/campaigns/skipped-recipients)

  ## Suppression List in Contacts (May 3rd)

  A new **Contacts, Suppression** view tracks blocked addresses from bounces, complaints, unsubscribes, and manual entries. It includes reason filters, row detail (SMTP subtype, complaint type, soft-bounce streak), and inline add or remove, so list hygiene lives where your contacts do.

  [Suppression list](/sending-domains/suppression-list)
</Update>

<Update label="April 2026" description="Persona drafting, engagement segments, email folders, a metadata editor, and DNS handoff">
  ## Persona Drafting (April 27th)

  A new **Persona** option on create lets you pick a contact, audience, or tag to seed a draft. Variable suggestions match the populated fields for that cohort, fields populated for under 5% of contacts are hidden, and **Personalise for…** appears on Tag, Audience, and Contact rows. Persona shapes the draft only, not send targeting, so you can write for a real reader without changing who receives the email.

  [Persona](/creating-emails/persona)

  ## Engagement Segments

  The segment editor now includes **Opened** and **Clicked** filters alongside **Received**, with time modes for in the past N days, not in the past N days, and never. Membership updates automatically as engagement events arrive, so segments stay current without manual maintenance.

  [Engagement segments](/audience/engagement-segments)

  ## Email Folders (April 22nd)

  Finder-style folders bring order to your emails with drag and drop, context-menu actions, and pinned folders, available on both desktop and mobile.

  ## Subject, Languages, and Variables

  A two-column editor with live preview opens from the email card menu, and updates apply to exports and linked campaigns so subject lines, languages, and variables stay consistent everywhere.

  ## Email DNS to Developer

  A new **Email to developer** action on sending domain records lets you hand off DNS setup with an optional note on the message and reply-to set to your address, making it easy to loop in whoever manages your domain.

  ## Bulk Image Upload

  The composer now supports multi-image drag and drop with parallel upload, so adding many images at once is quick.

  ## BCC

  BCC is now available on one-off and test sends.

  ## Subject Handling

  Migma now back-fills a campaign subject from the HTML `<title>` at send when the subject is empty, and renaming an email updates the exported HTML `<title>`, keeping subjects and titles aligned.
</Update>

<Update label="March 2026" description="Campaign archiving">
  ## Campaign Archiving (March 15th)

  You can now archive and unarchive campaigns from the campaign actions menu in any status. Archived campaigns keep their stats and history, a new **Archived** tab keeps the workspace tidy, and the capability is exposed in the SDK and MCP.
</Update>

<Update label="February 2026" description="Campaigns and analytics, the marketing calendar, dynamic styles, competitor tracking, sending, and developer tools">
  ## Per-Project Integrations (February 24th)

  Klaviyo, Mailchimp, and Brevo are now scoped to projects, configurable from the export dialog or project settings, so each brand keeps its own destinations.

  ## Figma Token Persistence

  Migma now stores a Figma personal access token per project, so importing private files no longer requires re-authenticating each time.

  ## Custom Font Upload

  Drag and drop font files (WOFF, WOFF2, TTF, OTF) to add brand fonts. Fonts are per-project and served from CDN.

  ## Managed Domain Reputation

  Bounce and complaint thresholds on Quick Start domains are tighter, and warning and suspend limits now appear on metric hover so reputation risk is visible before it becomes a problem.

  ## Automatic Domain Warming

  Warmup now starts automatically when a managed domain verifies, ramping daily send volume gradually to build sending reputation safely.

  This was replaced on August 25, 2026. Managed Migma addresses now use a fixed daily limit without warmup.

  ## Campaign Management (February 20th)

  A new 5-step campaign wizard and a campaign dashboard with status filters, search, and actions make it straightforward to plan and track sends.

  <Frame>
    <img alt="Campaign dashboard" />
  </Frame>

  [Send a campaign](/campaigns/send-campaign)

  ## A/B Testing

  Run variant tests on a subset of your audience with open and click comparison, then choose which version to send to the remainder.

  [Campaigns](/campaigns/overview)

  ## Campaign Analytics

  Cross-campaign metrics now cover sends, opens, clicks, bounces, and unsubscribes, so you can see performance across your whole program in one place.

  [Track results](/campaigns/track-results)

  ## Email Activity Dashboard

  A new activity dashboard surfaces delivery, engagement, bounce, and complaint trends, a country breakdown, and filtered email logs.

  ## Inbox Icons

  Emails can now show BIMI, Gravatar, and Google Profile inbox avatars, strengthening brand recognition in the inbox.

  [Inbox icons](/campaigns/inbox-icons)

  ## Bot Protection

  Migma now filters bot opens and clicks, including Apple Mail Privacy Protection, so engagement metrics reflect real recipients.

  ## Also Ships

  * Campaign scheduling with timezone and cancel before send
  * Campaign duplication
  * Geographic engagement map
  * Email log search
  * Deliverability docs
  * Migma vs Resend comparison doc

  ## Marketing Calendar (February 16th)

  A brand-aware marketing calendar lets you create a campaign in one click from any date, so planning and creation happen in the same view.

  <Frame>
    <img alt="Marketing calendar" />
  </Frame>

  ## Dynamic Email Styles

  Migma now detects a site's design system on brand import and applies it to generated emails, so output matches the brand automatically.

  <Frame>
    <img alt="Dynamic styles" />
  </Frame>

  ## Settings Page

  The settings page is redesigned around usage, sending rates, and account activity for a clearer view of your workspace.

  <Frame>
    <img alt="Settings" />
  </Frame>

  ## Developer Tools

  A full set of developer entry points is now available:

  * [OpenClaw](/openclaw): chat apps via the OpenClaw skill
  * [Skills](/skills): agent integrations
  * [CLI](/cli): terminal workflows
  * [MCP](/mcp-server): MCP clients

  ## Daily Calendar Email

  A morning digest summarizes upcoming campaign dates with create links, so the calendar comes to your inbox.

  <Frame>
    <img alt="Calendar digest email" />
  </Frame>

  ## Also Ships

  * Brand insights on email strategy
  * Bulk subscriber edit
  * Topic opt-in in preference center
  * Domain stack detection on brand import

  ## Competitor Tracking, Sending, Audience, GIFs, Editor (February 8th)

  A broad release adds competitor tracking, native sending, audience tooling, GIF Studio, and visual editing — the building blocks of a full email program.

  <Frame>
    <video alt="Migma email platform product overview" aria-label="Migma email platform product overview" />
  </Frame>

  ## Competitor Tracking

  Subscribe to competitor newsletters, view their sends, see a 12-month cadence heatmap, and remix anything into your own brand.

  <Frame>
    <img alt="Competitor tracking" />
  </Frame>

  [Competitor tracking](/creating-emails/competitor-tracking)

  ## Send From Migma

  Send directly from Migma with options for every stage:

  * **Quick Start**: a shared `@migma.email` sender
  * **Custom domain**: dedicated IP, Cloudflare DNS assist, and warmup
  * **Metrics**: delivery, opens, and clicks

  <Frame>
    <img alt="Send from Migma" />
  </Frame>

  <Frame>
    <img alt="Domain setup" />
  </Frame>

  [Sending domains](/sending-domains/overview)

  ## Audience and Contacts

  Audience tooling now covers validation on import, CSV bulk import, tags, dynamic segments, and per-contact engagement.

  <Frame>
    <img alt="Audience" />
  </Frame>

  [Manage contacts](/audience/manage-contacts)

  ## GIF Studio

  Generate brand-matched slideshows, reveals, and countdown GIFs to add motion to emails.

  <Frame>
    <img alt="GIF Studio" />
  </Frame>

  [Animated GIFs](/content-hub/animated-gifs)

  ## Visual Editor

  Point-and-click editing now covers text, images, colors, and styles, so refining a generated email is direct and visual.

  [Visual editor](/email-editor/visual-editor)

  ## Export

  Export to Mailchimp, Klaviyo, Brevo, HubSpot, and HTML download.

  <Frame>
    <img alt="Export destinations" />
  </Frame>

  [Export options](/email-editor/export-options)

  ## Referral Program

  Earn 30% recurring commission, and referrals get 50% off the first 3 months.

  <Frame>
    <img alt="Referrals" />
  </Frame>

  [Referral program](/referral/overview)

  ## Node.js SDK

  The Node.js SDK lets you import brands and generate emails programmatically:

  ```bash theme={null}
  yarn add migma
  ```

  ```typescript theme={null}
  import Migma from 'migma';

  const migma = new Migma(process.env.MIGMA_API_KEY);

  // Import a brand and wait for completion
  const brand = await migma.projects.importAndWait({
    urls: ['https://yourbrand.com']
  });

  // Generate an email and wait for completion
  const email = await migma.emails.generateAndWait({
    projectId: brand.data.projectId,
    prompt: 'Create a welcome email for new subscribers',
    languages: ['en']
  });

  console.log(email.data.result.html);
  ```

  [SDK](https://docs.migma.ai/sdk)

  ## Tutorials

  New tutorials walk through the headline workflows:

  <CardGroup>
    <Card title="Competitor tracking" icon="binoculars" href="/creating-emails/competitor-tracking">
      Subscribe, heatmap cadence, remix competitor emails.
    </Card>

    <Card title="Send from OpenClaw" icon="lobster" href="/tutorials/send-emails-from-openclaw">
      Send from WhatsApp, Telegram, or Discord via OpenClaw.
    </Card>

    <Card title="Localized campaigns" icon="globe" href="/tutorials/send-localized-emails">
      One campaign, per-subscriber language rendering.
    </Card>
  </CardGroup>
</Update>

<Update label="January 2026" description="The v3.0 launch with sending domains, audience tools, integrations, and the public API">
  ## Icons, GIF Slideshows, Countdown Timers (January 26th)

  This release adds an icons library, multi-image GIF slideshows, and countdown GIFs, plus an instant credit grant when you upgrade your plan so new capacity is available immediately.

  ## Icon Editing in Visual Editor (January 22nd)

  You can now swap icons directly inside the visual editor without leaving the canvas.

  ## Test Send to Any Address (January 21st)

  Test sends now accept an arbitrary recipient, so you can preview an email in any inbox before going live.

  ## Mobile and Dark Mode Generation (January 19th)

  Responsive layouts are improved and dark and light client rendering is more reliable, so generated emails look right across devices and themes.

  ## Email Generation Status API (January 17th)

  The status endpoint now returns HTML, screenshot URLs, stats (images, buttons, colors), and detected languages, giving integrations a complete picture of a generated email.

  [API reference](/api-reference/introduction)

  ## Integrations (January 15th)

  New integrations land for Zapier, Short.io, Close CRM, Meta Ads, monday.com, and Asana, and Figma now uses the native MCP server.

  ## Bug Fixes (January 11th)

  * Fixes MCP connector connections
  * Fixes Klaviyo API connection reliability

  ## v3.0.0 Launch (January 6th)

  The v3.0.0 release pairs a full redesign with sending domains, audience tools, GIF studio, custom fonts, referrals, and a public API — Migma's biggest step toward an end-to-end email platform.

  <Frame>
    <iframe title="Introducing the New Migma" />
  </Frame>

  ## Brand and UI

  A new logo and app shell arrive with light and dark themes.

  <Frame>
    <img alt="New brand" />
  </Frame>

  <Frame>
    <img alt="Light and dark mode" />
  </Frame>

  ## Sending Domains

  Set up managed or custom domains with warmup, DKIM/SPF/DMARC, MAIL FROM, bounce and complaint monitoring, and Cloudflare DNS assist.

  [Sending domains](/sending-domains/overview)

  ## Audience

  Audience tooling adds tags, dynamic segments, a preference center, CSV import with validation, and multi-language support per subscriber.

  [Audience](/audience/manage-contacts)

  ## Referral Program

  Earn 30% recurring commission while referrals get 50% off for 3 months, with milestone bonuses and multiple payout methods.

  [Referral program](/referral/overview)

  ## Image Clone and Remix

  Create exact and brand-adapted clones from screenshots or saved emails, and remix from a trending library with one click.

  <Frame>
    <img alt="Remix trending emails" />
  </Frame>

  [Image clone](/creating-emails/image-clone)

  ## Custom Fonts, GIF Studio, Social and Blog Export

  Upload custom fonts, generate GIFs from prompts or images, turn emails into social posts and blog content, and export to PDF and PNG.

  <Frame>
    <img alt="Custom fonts" />
  </Frame>

  ## Public API

  A public API opens Migma to programmatic workflows.

  [API reference](/api-reference/introduction)

  ## Also Ships

  * Improved generation memory and post-generation suggestions
  * CDN image optimization
  * Visual editor image controls
  * Composer queue during generation
  * Klaviyo export reliability fixes
</Update>

<Update label="December 2025" description="Export to 7+ platforms, the analysis dashboard, trending emails, and the Brand Kit">
  ## Custom Fonts and Brand Versions (December 20th)

  * Adds custom font upload
  * Adds brand version history and restore
  * Adds tag search on trending emails
  * Adds shareable preflight result links
  * Improves design generation speed

  ## Search and Smart Tags (December 19th)

  * Adds full-text search in conversations
  * Adds AI tags in Remix
  * Adds project version restore
  * Adds semantic search

  ## Brand Kit Page (December 13th)

  * Adds a Brand Kit page for assets
  * Improves tag filter performance

  ## Trending Emails (December 12th)

  * Adds a trending email gallery
  * Adds auto tags and titles on content

  ## Analysis Dashboard and CSS Checker (December 9th)

  * Adds a quality score dashboard
  * Adds a CSS checker for 20+ clients
  * Adds in-project chat
  * Improves dark mode in generated emails
  * Adds multi-language generation

  ## Export to 7+ Platforms (December 9th)

  Export to HTML, React, Klaviyo, HubSpot, Mailchimp, Brevo, and MJML with one click. Exported templates carry dark mode, accessibility, and client compatibility defaults.

  ## Live HTML Code Preview (December 8th)

  Adds a live HTML preview in preflight, so you can see the rendered markup as you work.

  ## Email Fixer and Device Preview (December 6th)

  * Adds one-click compatibility and link fixes
  * Adds previews for 20+ clients
  * Adds HTML to email conversion

  ## Bulk Import and Dark UI (December 4th)

  * Adds bulk contact import with dedupe and validation
  * Adds dark mode UI
  * Improves MJML export

  ## Export Speed and Social Posts (December 2nd)

  * Improves export performance
  * Adds a social post generator from emails
  * Improves brand import speed
</Update>

<Update label="November 2025" description="ESP integrations, on-brand AI images, and Figma conversion">
  ## ESP Integrations (November 28th)

  * Adds Mailchimp export
  * Adds HubSpot export
  * Adds Brevo export
  * Improves brand import time

  ## Images and Figma (November 21st)

  * Adds on-brand AI images
  * Adds Figma to email conversion
  * Adds image aspect ratio handling for layouts

  ## Figma Assets and Logos (November 5th)

  * Adds Figma image extract
  * Adds logo extraction on import
  * Improves default template patterns
</Update>

<Update label="October 2025" description="Email sequences, prompt enhancement, and AVIF output">
  ## Sequences and YouTube (October 31st)

  * Adds automated email sequences
  * Adds YouTube caption to email content
  * Improves preview image selection

  ## Prompt and Compatibility (October 27th)

  * Adds prompt enhancement before generation
  * Adds a design compatibility checker
  * Improves generation prompt handling

  ## AVIF and Icons (October 14th)

  * Adds AVIF images in email output
  * Adds a custom icon renderer
  * Improves image compression
</Update>


# AVIF and Icons
Source: https://docs.migma.ai/changelog/2025-10-14

Migma adds AVIF images to email output, introduces a custom icon renderer, and improves image compression for generated email layouts.

## AVIF and Icons

* Adds AVIF images in email output
* Adds a custom icon renderer
* Improves image compression


# Prompt and Compatibility
Source: https://docs.migma.ai/changelog/2025-10-27

Migma adds AI prompt enhancement before email generation, introduces a design compatibility checker, and improves how generation prompts are handled.

## Prompt and Compatibility

* Adds prompt enhancement before generation
* Adds a design compatibility checker
* Improves generation prompt handling


# Sequences and YouTube
Source: https://docs.migma.ai/changelog/2025-10-31

Migma adds automated email sequences, turns YouTube captions into email content, and improves how preview images are selected.

## Sequences and YouTube

* Adds automated email sequences
* Adds YouTube caption to email content
* Improves preview image selection


# Figma Assets and Logos
Source: https://docs.migma.ai/changelog/2025-11-05

Migma can extract images and logos from Figma during import, with improved default template patterns for converted email designs.

## Figma Assets and Logos

* Adds Figma image extract
* Adds logo extraction on import
* Improves default template patterns


# Images and Figma
Source: https://docs.migma.ai/changelog/2025-11-21

Migma adds on-brand AI image generation, converts Figma designs into emails, and handles image aspect ratios more reliably in layouts.

## Images and Figma

* Adds on-brand AI images
* Adds Figma to email conversion
* Adds image aspect ratio handling for layouts


# ESP Integrations
Source: https://docs.migma.ai/changelog/2025-11-28

Migma adds email export to Mailchimp, HubSpot, and Brevo, while reducing brand import time for faster setup across email workflows.

## ESP Integrations

* Adds Mailchimp export
* Adds HubSpot export
* Adds Brevo export
* Improves brand import time


# Export Speed and Social Posts
Source: https://docs.migma.ai/changelog/2025-12-02

Migma improves email export and brand import performance, and adds a generator that turns finished emails into social media posts.

## Export Speed and Social Posts

* Improves export performance
* Adds a social post generator from emails
* Improves brand import speed


# Bulk Import and Dark UI
Source: https://docs.migma.ai/changelog/2025-12-04

Migma adds bulk contact import with deduplication and validation, introduces a dark interface, and improves MJML export.

## Bulk Import and Dark UI

* Adds bulk contact import with dedupe and validation
* Adds dark mode UI
* Improves MJML export


# Email Fixer and Device Preview
Source: https://docs.migma.ai/changelog/2025-12-06

Migma adds one-click email compatibility and link fixes, previews across more than 20 email clients, and HTML-to-email conversion.

## Email Fixer and Device Preview

* Adds one-click compatibility and link fixes
* Adds previews for 20+ clients
* Adds HTML to email conversion


# Live HTML Code Preview
Source: https://docs.migma.ai/changelog/2025-12-08

Migma adds a live HTML code preview to Email Preflight, letting you see rendered markup update while editing before export or send.

## Live HTML Code Preview

Adds a live HTML preview in preflight, so you can see the rendered markup as you work.


# Analysis Dashboard and CSS Checker
Source: https://docs.migma.ai/changelog/2025-12-09

Migma adds a quality dashboard, CSS checks for more than 20 email clients, in-project chat, multilingual generation, and better dark mode.

## Analysis Dashboard and CSS Checker

* Adds a quality score dashboard
* Adds a CSS checker for 20+ clients
* Adds in-project chat
* Improves dark mode in generated emails
* Adds multi-language generation


# Export to 7+ Platforms
Source: https://docs.migma.ai/changelog/2025-12-09-2

Export to HTML, React, Klaviyo, HubSpot, Mailchimp, Brevo, and MJML with one click. Exported templates carry dark mode, accessibility, and client compatibility defaults.

## Export to 7+ Platforms

Export to HTML, React, Klaviyo, HubSpot, Mailchimp, Brevo, and MJML with one click. Exported templates carry dark mode, accessibility, and client compatibility defaults.


# Trending Emails
Source: https://docs.migma.ai/changelog/2025-12-12

Migma adds a gallery for browsing trending emails, with automatically generated tags and titles that make relevant examples easier to find.

## Trending Emails

* Adds a trending email gallery
* Adds auto tags and titles on content


# Brand Kit Page
Source: https://docs.migma.ai/changelog/2025-12-13

Migma adds a dedicated Brand Kit page for managing brand assets and improves tag filter performance when browsing content.

## Brand Kit Page

* Adds a Brand Kit page for assets
* Improves tag filter performance


# Search and Smart Tags
Source: https://docs.migma.ai/changelog/2025-12-19

Migma adds full-text conversation search, AI-generated tags in Remix, project version restoration, and semantic search across content.

## Search and Smart Tags

* Adds full-text search in conversations
* Adds AI tags in Remix
* Adds project version restore
* Adds semantic search


# Custom Fonts and Brand Versions
Source: https://docs.migma.ai/changelog/2025-12-20

Migma adds custom font uploads, brand version history and restore, trending email tag search, shareable preflight links, and faster design generation.

## Custom Fonts and Brand Versions

* Adds custom font upload
* Adds brand version history and restore
* Adds tag search on trending emails
* Adds shareable preflight result links
* Improves design generation speed


# Migma v3.0.0 Launch
Source: https://docs.migma.ai/changelog/2026-01-06

Migma v3.0.0 introduces a redesigned app, sending domains, audience tools, referrals, GIF and font tools, content exports, and a public API.

## v3.0.0 Launch

The v3.0.0 release pairs a full redesign with sending domains, audience tools, GIF studio, custom fonts, referrals, and a public API — Migma's biggest step toward an end-to-end email platform.

<Frame>
  <iframe title="Introducing the New Migma" />
</Frame>

## Brand and UI

A new logo and app shell arrive with light and dark themes.

<Frame>
  <img alt="New brand" />
</Frame>

<Frame>
  <img alt="Light and dark mode" />
</Frame>

## Sending Domains

Set up managed or custom domains with warmup, DKIM/SPF/DMARC, MAIL FROM, bounce and complaint monitoring, and Cloudflare DNS assist.

[Sending domains](/sending-domains/overview)

## Audience

Audience tooling adds tags, dynamic segments, a preference center, CSV import with validation, and multi-language support per subscriber.

[Audience](/audience/manage-contacts)

## Referral Program

Earn 30% recurring commission while referrals get 50% off for 3 months, with milestone bonuses and multiple payout methods.

[Referral program](/referral/overview)

## Image Clone and Remix

Create exact and brand-adapted clones from screenshots or saved emails, and remix from a trending library with one click.

<Frame>
  <img alt="Remix trending emails" />
</Frame>

[Image clone](/creating-emails/image-clone)

## Custom Fonts, GIF Studio, Social and Blog Export

Upload custom fonts, generate GIFs from prompts or images, turn emails into social posts and blog content, and export to PDF and PNG.

<Frame>
  <img alt="Custom fonts" />
</Frame>

## Public API

A public API opens Migma to programmatic workflows.

[API reference](/api-reference/introduction)

## Also Ships

* Improved generation memory and post-generation suggestions
* CDN image optimization
* Visual editor image controls
* Composer queue during generation
* Klaviyo export reliability fixes


# Connection Reliability Fixes
Source: https://docs.migma.ai/changelog/2026-01-11

Migma fixes MCP connector connection failures and improves the reliability of Klaviyo API connections for integrated email workflows.

## Bug Fixes

* Fixes MCP connector connections
* Fixes Klaviyo API connection reliability


# New Email Platform Integrations
Source: https://docs.migma.ai/changelog/2026-01-15

New integrations land for Zapier, Short.io, Close CRM, Meta Ads, monday.com, and Asana, and Figma now uses the native MCP server.

## Integrations

New integrations land for Zapier, Short.io, Close CRM, Meta Ads, monday.com, and Asana, and Figma now uses the native MCP server.


# Email Generation Status API
Source: https://docs.migma.ai/changelog/2026-01-17

The email generation status API now returns HTML, screenshot URLs, image, button and color statistics, and detected languages.

## Email Generation Status API

The status endpoint now returns HTML, screenshot URLs, stats (images, buttons, colors), and detected languages, giving integrations a complete picture of a generated email.

[API reference](/api-reference/introduction)


# Mobile and Dark Mode Generation
Source: https://docs.migma.ai/changelog/2026-01-19

Responsive layouts are improved and dark and light client rendering is more reliable, so generated emails look right across devices and themes.

## Mobile and Dark Mode Generation

Responsive layouts are improved and dark and light client rendering is more reliable, so generated emails look right across devices and themes.


# Test Send to Any Address
Source: https://docs.migma.ai/changelog/2026-01-21

Migma test sends can now use any recipient address, making it easier to preview an email in a real inbox before a live send.

## Test Send to Any Address

Test sends now accept an arbitrary recipient, so you can preview an email in any inbox before going live.


# Icon Editing in Visual Editor
Source: https://docs.migma.ai/changelog/2026-01-22

Migma now lets you replace icons directly in the Visual Editor, so you can adjust an email design without leaving the canvas.

## Icon Editing in Visual Editor

You can now swap icons directly inside the visual editor without leaving the canvas.


# Icons, GIF Slideshows, Countdown Timers
Source: https://docs.migma.ai/changelog/2026-01-26

Migma adds an icon library, multi-image GIF slideshows, countdown GIFs, and immediate credit grants when a plan upgrade completes.

## Icons, GIF Slideshows, Countdown Timers

This release adds an icons library, multi-image GIF slideshows, and countdown GIFs, plus an instant credit grant when you upgrade your plan so new capacity is available immediately.


# Competitor Tracking, Sending, Audience, GIFs, Editor
Source: https://docs.migma.ai/changelog/2026-02-08

A broad release adds competitor tracking, native sending, audience tooling, GIF Studio, and visual editing — the building blocks of a full email program.

## Competitor Tracking, Sending, Audience, GIFs, Editor

A broad release adds competitor tracking, native sending, audience tooling, GIF Studio, and visual editing — the building blocks of a full email program.

<Frame>
  <video alt="Migma email platform product overview" aria-label="Migma email platform product overview" />
</Frame>

## Competitor Tracking

Subscribe to competitor newsletters, view their sends, see a 12-month cadence heatmap, and remix anything into your own brand.

<Frame>
  <img alt="Competitor tracking" />
</Frame>

[Competitor tracking](/creating-emails/competitor-tracking)

## Send From Migma

Send directly from Migma with options for every stage:

* **Quick Start**: a shared `@migma.email` sender
* **Custom domain**: dedicated IP, Cloudflare DNS assist, and warmup
* **Metrics**: delivery, opens, and clicks

<Frame>
  <img alt="Send from Migma" />
</Frame>

<Frame>
  <img alt="Domain setup" />
</Frame>

[Sending domains](/sending-domains/overview)

## Audience and Contacts

Audience tooling now covers validation on import, CSV bulk import, tags, dynamic segments, and per-contact engagement.

<Frame>
  <img alt="Audience" />
</Frame>

[Manage contacts](/audience/manage-contacts)

## GIF Studio

Generate brand-matched slideshows, reveals, and countdown GIFs to add motion to emails.

<Frame>
  <img alt="GIF Studio" />
</Frame>

[Animated GIFs](/content-hub/animated-gifs)

## Visual Editor

Point-and-click editing now covers text, images, colors, and styles, so refining a generated email is direct and visual.

[Visual editor](/email-editor/visual-editor)

## Export

Export to Mailchimp, Klaviyo, Brevo, HubSpot, and HTML download.

<Frame>
  <img alt="Export destinations" />
</Frame>

[Export options](/email-editor/export-options)

## Referral Program

Earn 30% recurring commission, and referrals get 50% off the first 3 months.

<Frame>
  <img alt="Referrals" />
</Frame>

[Referral program](/referral/overview)

## Node.js SDK

The Node.js SDK lets you import brands and generate emails programmatically:

```bash theme={null}
yarn add migma
```

```typescript theme={null}
import Migma from 'migma';

const migma = new Migma(process.env.MIGMA_API_KEY);

// Import a brand and wait for completion
const brand = await migma.projects.importAndWait({
  urls: ['https://yourbrand.com']
});

// Generate an email and wait for completion
const email = await migma.emails.generateAndWait({
  projectId: brand.data.projectId,
  prompt: 'Create a welcome email for new subscribers',
  languages: ['en']
});

console.log(email.data.result.html);
```

[SDK](https://docs.migma.ai/sdk)

## Tutorials

New tutorials walk through the headline workflows:

<CardGroup>
  <Card title="Competitor tracking" icon="binoculars" href="/creating-emails/competitor-tracking">
    Subscribe, heatmap cadence, remix competitor emails.
  </Card>

  <Card title="Send from OpenClaw" icon="lobster" href="/tutorials/send-emails-from-openclaw">
    Send from WhatsApp, Telegram, or Discord via OpenClaw.
  </Card>

  <Card title="Localized campaigns" icon="globe" href="/tutorials/send-localized-emails">
    One campaign, per-subscriber language rendering.
  </Card>
</CardGroup>


# Marketing Calendar and Developer Tools
Source: https://docs.migma.ai/changelog/2026-02-16

A brand-aware marketing calendar lets you create a campaign in one click from any date, so planning and creation happen in the same view.

## Marketing Calendar

A brand-aware marketing calendar lets you create a campaign in one click from any date, so planning and creation happen in the same view.

<Frame>
  <img alt="Marketing calendar" />
</Frame>

## Dynamic Email Styles

Migma now detects a site's design system on brand import and applies it to generated emails, so output matches the brand automatically.

<Frame>
  <img alt="Dynamic styles" />
</Frame>

## Settings Page

The settings page is redesigned around usage, sending rates, and account activity for a clearer view of your workspace.

<Frame>
  <img alt="Settings" />
</Frame>

## Developer Tools

A full set of developer entry points is now available:

* [OpenClaw](/openclaw): chat apps via the OpenClaw skill
* [Skills](/skills): agent integrations
* [CLI](/cli): terminal workflows
* [MCP](/mcp-server): MCP clients

## Daily Calendar Email

A morning digest summarizes upcoming campaign dates with create links, so the calendar comes to your inbox.

<Frame>
  <img alt="Calendar digest email" />
</Frame>

## Also Ships

* Brand insights on email strategy
* Bulk subscriber edit
* Topic opt-in in preference center
* Domain stack detection on brand import


# Campaign Management
Source: https://docs.migma.ai/changelog/2026-02-20

A new 5-step campaign wizard and a campaign dashboard with status filters, search, and actions make it straightforward to plan and track sends.

## Campaign Management

A new 5-step campaign wizard and a campaign dashboard with status filters, search, and actions make it straightforward to plan and track sends.

<Frame>
  <img alt="Campaign dashboard" />
</Frame>

[Send a campaign](/campaigns/send-campaign)

## A/B Testing

Run variant tests on a subset of your audience with open and click comparison, then choose which version to send to the remainder.

[Campaigns](/campaigns/overview)

## Campaign Analytics

Cross-campaign metrics now cover sends, opens, clicks, bounces, and unsubscribes, so you can see performance across your whole program in one place.

[Track results](/campaigns/track-results)

## Email Activity Dashboard

A new activity dashboard surfaces delivery, engagement, bounce, and complaint trends, a country breakdown, and filtered email logs.

## Inbox Icons

Emails can now show BIMI, Gravatar, and Google Profile inbox avatars, strengthening brand recognition in the inbox.

[Inbox icons](/campaigns/inbox-icons)

## Bot Protection

Migma now filters bot opens and clicks, including Apple Mail Privacy Protection, so engagement metrics reflect real recipients.

## Also Ships

* Campaign scheduling with timezone and cancel before send
* Campaign duplication
* Geographic engagement map
* Email log search
* Deliverability docs
* Migma vs Resend comparison doc


# Per-Project Integrations
Source: https://docs.migma.ai/changelog/2026-02-24

Klaviyo, Mailchimp, and Brevo are now scoped to projects, configurable from the export dialog or project settings, so each brand keeps its own destinations.

## Per-Project Integrations

Klaviyo, Mailchimp, and Brevo are now scoped to projects, configurable from the export dialog or project settings, so each brand keeps its own destinations.

## Figma Token Persistence

Migma now stores a Figma personal access token per project, so importing private files no longer requires re-authenticating each time.

## Custom Font Upload

Drag and drop font files (WOFF, WOFF2, TTF, OTF) to add brand fonts. Fonts are per-project and served from CDN.

## Managed Domain Reputation

Bounce and complaint thresholds on Quick Start domains are tighter, and warning and suspend limits now appear on metric hover so reputation risk is visible before it becomes a problem.

## Automatic Domain Warming

Warmup now starts automatically when a managed domain verifies, ramping from 50 to 10,000+ emails per day over 20 days to build sending reputation safely.


# Campaign Archiving
Source: https://docs.migma.ai/changelog/2026-03-15

Archive completed or inactive Migma campaigns to keep the campaign list focused, while preserving their historical data and access when needed.

## Campaign Archiving

You can now archive and unarchive campaigns from the campaign actions menu in any status. Archived campaigns keep their stats and history, a new **Archived** tab keeps the workspace tidy, and the capability is exposed in the SDK and MCP.


# Email Folders
Source: https://docs.migma.ai/changelog/2026-04-22

Finder-style folders bring order to your emails with drag and drop, context-menu actions, and pinned folders, available on both desktop and mobile.

## Email Folders

Finder-style folders bring order to your emails with drag and drop, context-menu actions, and pinned folders, available on both desktop and mobile.

## Subject, Languages, and Variables

A two-column editor with live preview opens from the email card menu, and updates apply to exports and linked campaigns so subject lines, languages, and variables stay consistent everywhere.

## Email DNS to Developer

A new **Email to developer** action on sending domain records lets you hand off DNS setup with an optional note on the message and reply-to set to your address, making it easy to loop in whoever manages your domain.

## Bulk Image Upload

The composer now supports multi-image drag and drop with parallel upload, so adding many images at once is quick.

## BCC

BCC is now available on one-off and test sends.

## Subject Handling

Migma now back-fills a campaign subject from the HTML `<title>` at send when the subject is empty, and renaming an email updates the exported HTML `<title>`, keeping subjects and titles aligned.


# Persona Drafting
Source: https://docs.migma.ai/changelog/2026-04-27

Migma lets you seed an email draft from a contact, tag, or audience, and build dynamic segments from received, opened, or clicked activity.

## Persona Drafting

A new **Persona** option on create lets you pick a contact, audience, or tag to seed a draft. Variable suggestions match the populated fields for that cohort, fields populated for under 5% of contacts are hidden, and **Personalise for…** appears on Tag, Audience, and Contact rows. Persona shapes the draft only, not send targeting, so you can write for a real reader without changing who receives the email.

[Persona](/creating-emails/persona)

## Engagement Segments

The segment editor now includes **Opened** and **Clicked** filters alongside **Received**, with time modes for in the past N days, not in the past N days, and never. Membership updates automatically as engagement events arrive, so segments stay current without manual maintenance.

[Engagement segments](/audience/engagement-segments)


# Suppression List in Contacts
Source: https://docs.migma.ai/changelog/2026-05-03

Migma adds a Suppression view in Contacts with reason filters, bounce and complaint details, and inline controls for adding or removing addresses.

## Suppression List in Contacts

A new **Contacts, Suppression** view tracks blocked addresses from bounces, complaints, unsubscribes, and manual entries. It includes reason filters, row detail (SMTP subtype, complaint type, soft-bounce streak), and inline add or remove, so list hygiene lives where your contacts do.

[Suppression list](/sending-domains/suppression-list)


# Skipped Recipients Per Campaign
Source: https://docs.migma.ai/changelog/2026-05-04

Campaign recipients now include a Skipped tab with exclusion reasons, reason filters, and direct links to each affected contact.

## Skipped Recipients Per Campaign

A new **Skipped** sub-tab sits under campaign **Recipients** next to **Sent**, listing pre-send exclusions with their reason. Filter by reason and open the contact directly from a row to understand exactly why someone did not receive a campaign.

[Skipped recipients](/campaigns/skipped-recipients)


# Deliverability Settings
Source: https://docs.migma.ai/changelog/2026-05-05

A new Settings, Email, Deliverability area gives you more control over who you send to and how list health is maintained.

## Deliverability Settings

A new **Settings, Email, Deliverability** area gives you more control over who you send to and how list health is maintained:

* **Exclude risky addresses**: an optional toggle skips disposable and role addresses on send, and skipped campaigns list the reason `risky`.
* **Daily re-validation**: a nightly re-check for subscribed contacts whose validation is older than 30 days.
* **Segment validation filter**: scope segments by `valid`, `invalid`, `risky`, or `unknown`, and contact detail now shows **Last validated**.

[Deliverability](/audience/deliverability)


# Import Paths Render to Email-Safe HTML
Source: https://docs.migma.ai/changelog/2026-05-31

Prompt, Figma, image, HTML, and Claude design imports now all render to the same table-based HTML for Outlook, Gmail, Apple Mail, and mobile.

## Import Paths Render to Email-Safe HTML

Prompt, Figma, image, HTML, and Claude design imports now all render to the same table-based HTML for Outlook, Gmail, Apple Mail, and mobile. However you bring a design into Migma, it ends up as email that behaves consistently in the inbox.

## Claude Design Import

You can now import Claude design exports as editable Migma emails, turning agent-generated designs into something you can refine and send.

[Claude design](/creating-emails/claude-design)

## HTML Import

Paste or upload external HTML and Migma converts legacy templates into compatible Migma email, so existing assets can move into the workflow without a rebuild.

[HTML import](/creating-emails/html-import)

## Figma and Image Import

Figma frame conversion is improved for layout, spacing, and typography, and screenshot and mockup conversion lands closer to the source for higher fidelity from the start.

[Figma import](/creating-emails/figma-import) · [Image clone](/creating-emails/image-clone)

## Client Compatibility

All creation and import paths render to table-based HTML, including desktop Outlook (Word rendering). Migma sets `color-scheme` and optional locked brand colors, and preflight reports pass, warning, or fail per client so you know exactly how an email will land before sending.

[Client compatibility](/email-editor/client-compatibility)


# Collaboration, Canvas, and Email Series
Source: https://docs.migma.ai/changelog/2026-05-31-2

Migma adds project roles, live cursors, shared canvas editing, and multi-email series so teams can plan and refine complete sequences together.

## Collaboration, Canvas, and Email Series

Migma now supports real-time team editing on a shared visual canvas alongside multi-email series workflows. Teams can plan, draft, and refine entire sequences together in one space.

## Team Access

Projects now have roles — Manager, Editor, Commenter, and Viewer — plus account-level invites that apply across all projects. Manage members and pending invites from project settings.

[Team access](/collaboration/team-access)

## Real-Time Collaboration

Collaboration gains presence avatars, live cursors and focus, canvas sync, and a generating indicator that shows when another member is running generation, so the whole team stays in sync as they work.

[Real-time collaboration](/collaboration/realtime)

## Visual Canvas

A new spatial board holds emails, social posts, and blog nodes in one place. Pin HTML references, images, URLs, and competitor emails, and use sticky notes, flow lines, groups, and canvas version restore to plan campaigns visually.

[Visual canvas](/creating-emails/visual-canvas)

## Email Series

Generate a multi-email series from one brief, then add, remove, or reorder emails. Batch edit across the series, set per-email cadence, and restore prior versions per email — the full sequence is editable, not locked.

[Email series](/creating-emails/email-series)


# Campaign Publishing Dialog
Source: https://docs.migma.ai/changelog/2026-06-01

The publishing dialog is redesigned for send, export, and API options, with clearer tabs, better recipient copy, refined typography, and improved preview controls.

## Campaign Publishing Dialog

The publishing dialog is redesigned for send, export, and API options, with clearer tabs, better recipient copy, refined typography, and improved preview controls. Choosing how a campaign goes out is now faster to understand at a glance.


# Voice Dictation in Composer
Source: https://docs.migma.ai/changelog/2026-06-01-2

Migma adds voice dictation to the composer, transcribing speech into prompts for individual emails and complete email series briefs.

## Voice Dictation in Composer

The prompt bar now has a mic control. Speech transcribes directly into the composer for both single emails and series briefs, so you can describe what you want out loud instead of typing it.


# Proprietary Email Engine
Source: https://docs.migma.ai/changelog/2026-06-04

Migma's rendering engine produces table-based HTML for Outlook, webmail, and mobile, with client previews and a per-project image generation toggle.

## Proprietary Email Engine

Migma's email rendering engine now powers output. Emails render to table-based HTML for Outlook, webmail, and mobile, and preflight adds client previews before send so you can catch rendering issues before subscribers do.

[Client compatibility](/email-editor/client-compatibility)

## Image Generation Toggle

A per-project toggle now controls the image and GIF generator, so you can turn generated imagery on or off depending on the brand or workflow.

[AI image generation](/content-hub/ai-image-generation)


# Agencies and Client Brands
Source: https://docs.migma.ai/changelog/2026-06-07

New guidance helps agencies run client work cleanly. Keep each client in its own workspace with your team as editors, or join a client's brand as a guest.

## Agencies and Client Brands

New guidance helps agencies run client work cleanly. Keep each client in its own workspace with your team as editors, or join a client's brand as a guest. Editors use a seat, reviewers stay free, and the workspace owner is billed, so the billing and access model matches how agency engagements actually work.

[Agencies & client brands](/collaboration/agencies)


# Free Collaborators
Source: https://docs.migma.ai/changelog/2026-06-10

Migma adds seat-free editors and managers who collaborate in real time on shared projects and use AI generation credits from their own plans.

## Free Collaborators

Migma now offers a seat-free way to invite editors and managers. Owners and admins check **Free collaborator** when inviting from a brand's Share panel or from Settings, People & Access. Free collaborators edit and collaborate in real time without using a seat, and AI generation runs on their own plan's credits. People they invite stay seat-free automatically, so teams and agencies can scale collaboration without scaling seat costs.

[Seats](/collaboration/seats)


# Account Security
Source: https://docs.migma.ai/changelog/2026-06-12

Migma adds two-factor authentication, natural-language segment drafting, smarter contact filters, an agent setup flow, and clearer live presence.

## Account Security

Two-factor authentication is now available from Settings. Use an authenticator app or emailed security codes, verify your email address, and download backup codes for account recovery, so your workspace stays protected even if a password leaks.

## Smart Segmentation

Contacts now supports natural-language segment drafting. Describe an audience like "inactive subscribers in Spain" and Migma builds the matching filters for you. Contact search also gains smart filtering, custom-field filters, activity filters, live counts, and post-import segment suggestions, so targeting is faster and far less manual.

[Manage contacts](/audience/manage-contacts) · [Tags and segments](/audience/manage-tags-and-segments)

## Setup Skill

A new **Set up Migma** action on Create copies `/setup` instructions with sender status, agent auth guidance, and skill or plugin install paths. Coding agents use it to audit the app, create emails, and wire safe backend sends without guesswork.

## Live Collaboration Polish

Shared workspace presence is clearer, with more legible member and agent activity while teams work on canvas. It is easier to tell at a glance who is doing what.

[Real-time collaboration](/collaboration/realtime)


# Agents Register Themselves
Source: https://docs.migma.ai/changelog/2026-06-13

AI agents can request Migma access, show a short approval code, and receive their own scoped API key after the user reviews and approves permissions.

## Agents Register Themselves

Agents can now register themselves with scoped API keys. An AI agent like Claude, Cursor, or OpenClaw asks to connect, you approve it with a short code at [migma.ai/claim](https://migma.ai/claim), and the agent receives its own scoped API key. You never create, copy, or paste a key. You see the agent's name and the permissions it requested before you confirm, and you can revoke any agent key from Settings, API Integration. Migma follows the open [auth.md](https://workos.com/auth-md/docs) convention, so agents discover and complete the whole flow on their own.

[Agent registration](/agent-registration)


# Agents and Teammates Show Up Live
Source: https://docs.migma.ai/changelog/2026-06-17

Migma improves live teammate and agent presence, converts searches and imports into saved segments, adds 2FA, and streamlines email series setup.

## Agents and Teammates Show Up Live

Presence, member avatars, and agent activity are now clearer while teams work together on canvas. You can see who is editing, where their focus is, and when an agent is generating, so collaboration feels coordinated instead of accidental.

[Real-time collaboration](/collaboration/realtime)

## Turn Searches and Imports Into Segments

Describe an audience in plain language, preview the matching contacts, and save the result as an AI-built segment after importing subscribers. The flow turns ad-hoc searches and fresh imports into reusable segments without leaving Contacts.

[Manage contacts](/audience/manage-contacts) · [Tags and segments](/audience/manage-tags-and-segments)

## Protect Accounts With 2FA

Two-factor authentication is now available account-wide. Use an authenticator app or emailed security codes, verify your email address, and download backup codes from Settings so you can recover access if you lose your device.

## Set Up Migma From Create

A new **Set up Migma** action on Create copies `/setup` instructions so coding agents can audit your app, create emails, and wire safe backend sends. It hands your agent everything it needs to integrate Migma correctly the first time.

[Setup skill](/setup)

## Create a Full Email Series in Under a Minute

Generate connected welcome, launch, nurture, and winback flows from a single prompt. Instead of building each message by hand, you describe the goal and Migma drafts the whole series ready to refine.

[Email series](/creating-emails/email-series)

## Realtime Collaboration and Workspaces

Share workspaces, invite teammates, and build emails together live. The whole team can work on the same canvas at once, so reviews and edits happen in place.

[Real-time collaboration](/collaboration/realtime) · [Team access](/collaboration/team-access)


# Build a Segment From Someone You Already Know
Source: https://docs.migma.ai/changelog/2026-06-20

Draft a lookalike audience by naming a contact, group contacts by values, dates, and numeric thresholds, and steer segments toward a specific campaign.

## Build a Segment From Someone You Already Know

<Frame>
  <img alt="Create New Segment dialog with the describe-in-words search box and filter rows" />
</Frame>

The plain-language segment box in **Contacts** now understands examples. Ask for "contacts like [alex@acme.com](mailto:alex@acme.com)" or "subscribers similar to my best customer" and Migma looks up that person, finds the traits that make them stand out from the rest of your audience, and drafts a lookalike segment from those. It skips traits almost everyone shares, and never targets on names or email addresses, so you get a real audience rather than a copy of one contact.

Plain-language drafting also reads attributes and engagement together, so requests like "pro plan contacts in France who opened recently" become filters you can review before saving. New **Try** chips under the box give you a starting phrase to edit.

You can also point engagement filters at one campaign, for example "people who received the launch but did not click it". Migma reads the campaign recipient log and tells you clearly when that activity is no longer retained.

## Group contacts by a value pattern

Ask for a group like "investors" and Migma looks at the real values in your contacts to find what they share, for example emails that end in ".vc", then writes one rule instead of listing every address. Because it is a rule, the segment keeps matching new contacts as they arrive. When you build filters by hand, field conditions now offer **starts with**, **ends with**, **contains**, and **does not contain** alongside the exact **is** and **is not**.

Improves field conditions for imported numeric and date values. Counts, prices, scores, and dates now appear as typed properties with matching operators, and plain-language drafting can suggest thresholds from real audience values.

[Tags and segments](/audience/manage-tags-and-segments) · [Engagement segments](/audience/engagement-segments)


# The New Migma: AI-Native Email Service Provider
Source: https://docs.migma.ai/changelog/2026-06-22

Migma becomes an AI-native email service provider with full-sequence canvas creation, AI segmentation, inbox rendering, collaboration, sending, and export.

Email has an agent now. Connect your brand, set a goal, and Migma turns it into production-ready email marketing. This is the biggest release yet: Migma is no longer just an AI email creator. It is now an AI-native ESP that helps teams create, segment, collaborate on, render, send, export, and improve email sequences from one workspace.

## Email Canvas: Full Sequences, Not Single Emails

You can now generate complete email sequences inside one canvas instead of designing one email at a time. Welcome, onboarding, product launch, abandoned cart, win-back, lifecycle, and transactional sequences are all generated from a single prompt. Every email in the sequence can be edited, rewritten, localized, personalized, and improved in the same workflow, so teams can shape the full customer journey instead of building isolated emails.

[Email series](/creating-emails/email-series) · [Visual canvas](/creating-emails/visual-canvas)

## Email Rendering Built for Inboxes

Migma now produces email-safe output for major inboxes, including Gmail, Outlook, Apple Mail, mobile, dark mode, light mode, and older clients. Designs should hold up when subscribers open them, not only inside the editor.

[Client compatibility](/email-editor/client-compatibility) · [Email preflight](/email-editor/email-preflight)

## AI Segmentation: The Right Email for the Right Segment

Migma now helps decide who should receive what. Create audience segments with AI, generate campaign variants for different customer groups, and personalize by language, country, persona, and audience context. A normal email designer creates one email; Migma creates the right email for the right segment, so each cohort gets a message that actually fits it.

[Manage contacts](/audience/manage-contacts) · [Tags and segments](/audience/manage-tags-and-segments) · [Engagement segments](/audience/engagement-segments)

## Workspaces and Realtime Collaboration

Email marketing is team work for founders, marketers, designers, agencies, clients, and operators. Migma now supports invites, seats, workspaces, comments, realtime editing, and campaign review in one canvas.

[Real-time collaboration](/collaboration/realtime) · [Workspaces](/collaboration/workspaces) · [Team access](/collaboration/team-access) · [Seats](/collaboration/seats)

## Agentic Handoff: Start From the Tools Your Team Already Uses

Migma can now work from the AI tools your team already uses, including Claude, Cursor, Lovable, Figma, screenshots, HTML, your website, files, references, and prompts. Agents can bring plans and source material into Migma, where teams can render, send, and export the emails.

[MCP servers](/integrations/mcp-servers) · [Setup skill](/setup) · [CLI](/cli) · [Design with Claude](/creating-emails/claude-design)

## Send and Export Through Your Stack

Teams can adopt Migma without rebuilding their entire email stack on day one. Send or export through Mailchimp, HubSpot, Klaviyo, and similar tools, and prepare marketing emails, transactional emails, brand and domain setup, and sending workflows from one place. Migma fits into the pipeline you already run instead of asking you to replace it.

[Mailchimp](/integrations/mailchimp) · [Klaviyo](/integrations/klaviyo) · [Email service providers](/integrations/email-service-providers) · [Sending domains](/sending-domains/overview)

## References, Files, Screenshots, Voice, and HTML Input

Real teams start with context. Migma can use files, screenshots, pasted HTML, design references, competitor examples, comments, and voice input. The more context you bring, the closer the first draft lands.

[HTML import](/creating-emails/html-import) · [Figma import](/creating-emails/figma-import) · [Image clone](/creating-emails/image-clone) · [Prompt-based creation](/creating-emails/prompt-based-creation)

## Performance Feedback Loop

Migma is moving from creation to optimization. Campaign feedback can guide future sends so teams create better messages over time.

[Domain metrics](/sending-domains/metrics)


# Remote MCP for AI Tools
Source: https://docs.migma.ai/changelog/2026-06-24

Migma adds remote MCP access for compatible AI tools and introduces Omnisend as an OAuth destination for exporting draft campaigns.

## Remote MCP for AI Tools

Adds remote MCP support so teams can connect Migma to MCP-compatible AI tools without running a local server. Once connected, agents can help create, send, validate, and export emails from the tools your team already uses.

Local setup remains available for teams that prefer it.

[MCP](/mcp-server)

## Omnisend Export

Adds Omnisend as an OAuth export destination from **Publish**. Connect a brand, export a draft campaign to Omnisend, or keep using HTML export when you want to import manually.

[Export options](/email-editor/export-options)


# API, Sender, and Agent Updates
Source: https://docs.migma.ai/changelog/2026-06-27

Adds batch contact deletion to the API. Remove many contacts by email in a single request, and get back a clear list of any emails that had no matching contact.

## API, sender, and agent updates

Adds batch contact deletion to the API. Remove many contacts by email in a single request, and get back a clear list of any emails that had no matching contact.

Adds From addresses to Sending Domains. Manage each domain's sender names and addresses, set the default sender, and keep Publish using the same verified sender list.

Adds idempotency for write requests. Retry a request after a network error or timeout and Migma replays the original result instead of doing the work twice, so a flaky connection never sends a duplicate email or creates a duplicate contact. The official SDK carries the key through its automatic retries for you.

Adds domain security to Sending Domains. If another team is using a domain you own, you can prove DNS ownership and claim it back to your workspace. Migma re-provisions the domain and prepares it for sending under your account.

Adds bot protection to public forms. Signup, login, password reset, waitlist, and careers forms now verify you are human before submitting.

Adds a redirect URL option when buying a domain. The domain apex can point to your brand site while you set up sending.

Adds campaign performance to the API, SDK, CLI, and MCP server. Read opens, clicks, bounces, and unsubscribes for any campaign, and pull the per recipient delivery log to see exactly who received, opened, and clicked.

Adds a capabilities tool and guided workflows to the MCP server. Your agent can ask Migma what it can do, then follow ready made recipes to design an email, send a test, launch a campaign, and read the results in one flow.

Improves the agent guide with a developer reference for letting an agent register for its own scoped key.

[Sending domains](/sending-domains/overview) · [Contacts API](/api-reference/introduction) · [MCP](/mcp-server) · [Bring your agent](/agent-auth)


# Email Metrics and Domain Warmup
Source: https://docs.migma.ai/changelog/2026-06-28

Migma adds per-email performance across app and developer tools, Copy for AI setup prompts, and configurable volume and growth for domain warmup.

## Per-email performance

Adds per-email performance to the app, API, SDK, CLI, and MCP server. Open a generated email's metrics to review delivery, opens, clicks, period deltas, campaign usage, transactional send logs, top locations, preflight status, and improvement options across every send of it.

Opens are directional and arrive over time, so clicks and delivery are stronger signals. Recent send rows are kept for about a month.

Adds **Copy for AI** to Publish and API setup surfaces, so coding agents can wire a selected Migma email into an app with a short setup prompt.

## Domain warmup controls

Improves **Domain Warming** with starting volume, daily growth, and safety settings before warmup starts. The Warming tab now shows today's cap, safe remaining capacity, the next cap, a schedule preview, and the bounce and complaint thresholds Migma will use.

Paused warmup now turns off warmup caps until you resume. Automatic safety pauses still protect risky domains.

[API reference](/api-reference/introduction) · [SDK](/sdk) · [CLI](/cli) · [MCP](/mcp-server) · [Domain warming](/sending-domains/domain-warming)


# Duplicate Emails and Series
Source: https://docs.migma.ai/changelog/2026-06-29

Duplicate an individual Migma email or a complete email series into a new chat while preserving the source content and starting a fresh workflow.

Adds **Duplicate in new chat** and **Duplicate series** to email card menus.

Both actions open the copied email or series in a new chat, so you can try another direction without changing the original.

[Visual canvas](/creating-emails/visual-canvas) · [Email series](/creating-emails/email-series)


# Draft-Only API Key Permissions
Source: https://docs.migma.ai/changelog/2026-06-30

Create draft-only Migma API keys that let agents and developer tools prepare email work without permission to send, schedule, or publish it.

Adds `email:write` for creating and editing generated emails without granting send access. API keys and agent registrations can now let tools prepare drafts while keeping test and live sends behind `email:send`.

Updates brand import and retry permissions to use `project:write`, matching the permissions shown in **Settings → Developers**.

[Authentication](/authentication) · [Agent registration](/agent-registration)


# Bulk contact imports
Source: https://docs.migma.ai/changelog/2026-07-01

Migma imports large CSV contact lists in the background with automatic field mapping, live status, update controls, and suggested segments.

Import large contact lists from a CSV without waiting on the page. Uploads process in the background, columns map to your contact fields automatically, and **Import History** shows a live breakdown of what was created, updated, skipped, and failed. Available in the dashboard and through the API, SDK, CLI, and MCP server.

* Import large lists from a CSV file, processed in the background
* Automatic column mapping to your contact fields
* Live status with created, updated, skipped, and failed counts
* Choose to update or skip contacts that already exist
* Suggested segments as soon as an import finishes

## Import from the dashboard

In **Contacts**, choose **Add Contact** then **Bulk Import** and upload your CSV. Migma matches each column to a contact field, with only Email required, and you confirm before it runs. The import processes in the background, so you can leave the page. Watch it finish in **Import History** with counts for imported, updated, and failed contacts and a summary of any rows that could not be added.

## Suggested segments after an import

When an import finishes, Migma suggests segments built from the contacts you just added, so a fresh list becomes a targeted audience in one step. Choose a suggestion to open the segment builder prefilled and ready to save.

## Import programmatically

Create and track imports from the API, SDK, CLI, and MCP server. Upload the CSV, then poll the import for its status and counts.

```typescript Node.js SDK theme={null}
import { readFileSync } from 'node:fs';
import Migma from 'migma';

const migma = new Migma('YOUR_API_KEY');

// Upload the CSV, processed in the background.
const { data: job } = await migma.contacts.imports.create({
  file: readFileSync('./contacts.csv'),
  projectId: 'PROJECT_ID',
  columnMap: { email: 'Email', firstName: 'First Name' },
  onConflict: 'upsert',
});

// Poll until it finishes.
const { data: status } = await migma.contacts.imports.get(job!.id);
```

A finished import reports counts you can reconcile against your file:

```json theme={null}
{
  "object": "contact_import",
  "id": "IMPORT_ID",
  "status": "completed",
  "counts": { "total": 1200, "created": 1150, "updated": 40, "skipped": 8, "failed": 2 }
}
```

## Update or skip existing contacts

Set `onConflict` to `upsert`, the default, to update contacts whose email already exists, which makes a re-import a safe way to refresh your list. Set it to `skip` to leave existing contacts untouched and only add new ones.

[Manage contacts](/audience/manage-contacts) · [API reference](/api-reference/introduction) · [SDK](/sdk) · [CLI](/cli) · [MCP](/mcp-server)


# Audience insights in email analytics
Source: https://docs.migma.ai/changelog/2026-07-02

Migma adds device, email client, top link, inbox provider, and engagement timing breakdowns to account activity and campaign analytics.

See who engages with your emails and where, straight from the **Activity** page. New breakdowns cover every send in your selected date range, and each campaign's **Analytics** tab shows the same view scoped to that campaign.

* Device split for opens and clicks across mobile, desktop, and webmail
* Email clients, showing how many readers engage from Gmail, Outlook, Yahoo, or Superhuman
* Top links, ranking every tracked link and button by clicks
* Inbox providers, with the open rate per provider to spot deliverability problems early
* Activity timing, showing when your audience opens and clicks through the day

## Spot deliverability problems by provider

The **Inbox providers** card shows open rates for Gmail, Outlook, Yahoo, and Apple recipients side by side. A provider with a much lower open rate than the rest usually means messages are landing in spam there, so you can act before it affects a whole campaign. Apple opens are inflated by Mail Privacy Protection and the card says so.

## See which links earn the click

**Top links** ranks the links across your sends by clicks, including which button or link in the design was clicked. Use it to learn which calls to action work and which go unnoticed.

## Same insights for each campaign

Open a campaign's **Analytics** tab to see the device, timing, email client, and inbox provider breakdowns for that campaign alone.

All engagement counts exclude bot and scanner activity, so the numbers reflect real readers.

[Send campaigns](/campaigns/send-campaign) · [Domain metrics](/sending-domains/metrics)


# MCP clients connect with OAuth
Source: https://docs.migma.ai/changelog/2026-07-02-2

OAuth-capable hosted MCP clients can connect to Migma through browser consent, receive a scoped key automatically, and be revoked from Settings.

Hosted MCP clients that support OAuth can now connect to Migma without manual API-key setup. Add `https://migma.ai/mcp` as the connector URL, sign in, review scopes on the Migma consent page, and approve the connection. Migma gives the client a scoped key automatically.

* Works for OAuth-capable hosted MCP clients, including claude.ai custom connectors
* Shows requested scopes before approval
* Highlights `email:send` when the client can send from your account
* Keeps manual bearer-key setup available
* Lets you revoke generated keys from **Settings → Developers → API Keys**

[MCP](/mcp-server) · [Agent auth](/agent-auth) · [Agent registration](/agent-registration)


# Brand settings redesign
Source: https://docs.migma.ai/changelog/2026-07-03

Migma reorganizes brand settings around Visual Identity, Brand Guidelines, and Footer sections, with a searchable settings sidebar.

Improves brand settings with a new layout. Open **All brand settings** from the chat header to see sections ordered the way an email reads, from visual identity through content to the footer.

## Visual Identity in one place

The new **Visual Identity** section groups **Logos**, **Colors & Styling**, and **Typography** as tabs, so everything that controls how your emails look sits together. The **Gallery** now holds brand images only.

## Search your settings

The sidebar has a **Search settings** box. Press slash to focus it, then search by setting name or by what lives inside a section, including connected tool names like Notion or Stripe.

## Brand Guidelines and AI Instructions

**Knowledge Base** is now **Brand Guidelines**, holding your reference emails, documents, and brand content. Generation rules live in their own **AI Instructions** section, so context and instructions each have a clear home under **Content**.

## Footer settings grouped

**Company Profile** and **Sitemap** now sit together under **Footer**, and social links are managed in **Sitemap**. **Brand Details** keeps the essentials, with your website shown as a link.

[Brand setup](/get-started/configure-brand) · [External MCP servers](/integrations/mcp-servers)


# Import contacts from Mailchimp, Klaviyo, and HubSpot
Source: https://docs.migma.ai/changelog/2026-07-03-2

Import contacts from Mailchimp audiences, Klaviyo lists, or HubSpot lists while preserving subscription status and creating a tagged Migma segment.

Adds **Import from integration** to the **Add Contact** menu on the Contacts page. Choose a connected provider, pick a source, and Migma imports the contacts in the background, so there is no CSV export step when moving an audience over.

## Supported sources

Mailchimp imports from audiences, saved segments, and tags. Klaviyo imports from lists and segments. HubSpot imports from contact lists. If a provider is not connected yet, you can connect it from the same screen, and CSV or paste import remains available as a fallback.

## Consent stays intact

By default only subscribed contacts are imported. You can optionally include non-subscribed and unsubscribed contacts for record keeping, and those stay non-sendable. HubSpot imports are conservative: contacts become sendable only when HubSpot subscription data shows an explicit opt-in. Existing unsubscribed or bounced contacts are never resubscribed.

## Ready-to-use audience

Every import creates a source tag named after the imported source, such as `Main Audience`, and a snapshot segment that targets it. Importing the same source again reuses both. **Import History** shows the provider, account, source, consent mode, and how many contacts were imported, updated, kept non-sendable, skipped, or failed.

[Mailchimp](/integrations/mailchimp) · [Klaviyo](/integrations/klaviyo) · [HubSpot](/integrations/hubspot) · [Manage contacts](/audience/manage-contacts)


# Events and conversion tracking API
Source: https://docs.migma.ai/changelog/2026-07-03-3

Adds POST /v1/events and /v1/events/batch so your backend can report customer events like purchases, trials, and refunds.

Adds `POST /v1/events` and `/v1/events/batch` so your backend can report customer events like purchases, trials, and refunds. Send a single event with an **Idempotency-Key** header, or batch up to 500 events with per-row dedupe keys and row-level partial success.

An event that carries an order identifier and a numeric value is recorded as a conversion and attributed to the last email the recipient clicked within the previous five days, credited once. Event names containing refund or cancelled record negative amounts, so returned revenue is subtracted instead of counted.

Conversions and revenue then appear in campaign stats, shown only when real activity has been reported so a campaign with no attributed revenue shows no figures rather than fake zeros. Events never change subscription status.

[Events](/events) · [API reference](/api-reference/introduction)


# Migma for Telegram Launch
Source: https://docs.migma.ai/changelog/2026-07-06

Use the Migma bot in Telegram to connect your account, list brands, create and edit branded email drafts, and receive previews without sending.

Adds **Migma for Telegram**, so you can create and edit branded emails from a Telegram chat or a group. Start a chat with the bot, connect your account once with the Telegram Login Widget, then ask it to list your brands, import a brand from a URL, generate emails, edit them, or find design inspiration. Attach an image to generate an email from it.

Connecting uses Telegram's verified Login Widget, so your identity is asserted by Telegram and nothing is pasted. The bot creates and edits drafts only. Sending, scheduling, and exporting stay in Migma, where you review and approve the send.

[Telegram](/integrations/telegram) · [Agent auth](/agent-auth)


# Marketing Calendar prepares your campaigns
Source: https://docs.migma.ai/changelog/2026-07-06-2

Migma's Marketing Calendar prepares campaigns with suggested audiences and send times, connects read-only Google Calendar events, and shows recent results.

Improves the **Marketing Calendar**: Migma now prepares upcoming calendar campaigns before you ask. Each item under **Prepared for you** is a finished email with a suggested audience and send time. Review it, click **Approve**, and the campaign is scheduled. Dismiss anything that does not fit.

Adds **Connect calendar**: link Google Calendar (read only) and real business events like launches and sales become planned emails anchored to their true dates.

Improves performance learning: recent sent campaigns now appear as subdued items on their calendar dates. Open one to see click and open rates. Migma uses delivered-weighted human clicks as the main timing signal and treats opens as supporting context.

Adds **Calendar settings**: turn on automatic email creation from your calendar (works with or without a connected calendar) and Migma prepares upcoming emails in the background, then emails you when they are ready, like "Your Black Friday email is ready to approve", with review links. Notifications have their own toggle. Migma skips anything you already created yourself, and you approve each email before it sends.

[Marketing Calendar](/campaigns/marketing-calendar) · [Send a Campaign](/campaigns/send-campaign)


# Click map for campaign emails
Source: https://docs.migma.ai/changelog/2026-07-09

Campaign analytics now include a click map that shows human clicks on email links and buttons while filtering bots, scanners, and system actions.

Adds **Click map** to each campaign's **Analytics** tab. See recorded human clicks directly on links and buttons in the sent email, with stronger intensity for actions clicked by more people. Select a marker to see its total clicks.

Bot and scanner activity stays hidden, along with system actions such as unsubscribe and preference links. The map shows which email action was clicked; email clients do not provide cursor coordinates.

[Track results](/campaigns/track-results)


# Comment threads on canvas
Source: https://docs.migma.ai/changelog/2026-07-11

Migma adds anchored Visual Canvas comment threads with mentions, replies, notifications, resolve controls, and expanded Commenter permissions.

Adds anchored comment threads to **Visual Canvas**. Place a comment beside an email, mention a teammate with `@`, reply in the thread, and resolve or reopen feedback without covering the canvas with sticky notes. Mention alerts open the exact thread and wait for teammates who are away. Comment markers show who started each thread and how many replies it contains.

Commenters can now create, reply to, move, and resolve canvas comments while email editing and sending stay disabled for their role. Unresolved feedback remains available to Migma during the next design turn. Resolved threads stay on canvas for reference without affecting later edits.

[Visual Canvas](/creating-emails/visual-canvas) · [Real-time collaboration](/collaboration/realtime) · [Team access](/collaboration/team-access)


# Founder Pass for Product Hunt
Source: https://docs.migma.ai/changelog/2026-07-11-2

Founder Pass offers eligible new customers a seven-day Premium trial, up to 200,000 monthly sends, and a $49 monthly price for the first 200.

Updates the limited **Founder Pass** with a direct Premium overview: up to 200,000 monthly sends for marketing and transactional email, API and hosted MCP access, analytics, and Slack and Telegram beta access.

Eligible new customers create an account, start a seven-day trial, then continue into setup. The first 200 keep the \$49 monthly Founder price while the qualifying subscription stays active.

[Claim Founder Pass](https://migma.ai/founder-pass)


# Deeper Brand Import
Source: https://docs.migma.ai/changelog/2026-07-16

Improves Brand Import: Migma now studies relevant About, product, pricing, news, and contact pages in addition to the homepage.

Improves **Brand Import**: Migma now studies relevant About, product, pricing, news, and contact pages in addition to the homepage. It learns the brand's products, positioning, copy and CTA patterns, footer details, social links, and observed icon or emoji style.

Useful findings appear in **Brand Guidelines** and guide future email design and copy. Recent public brand and industry updates are kept in one dated research entry, while anything you add manually stays untouched.

[Configure your brand](/get-started/configure-brand)


# Rename campaigns, chats, series, and emails
Source: https://docs.migma.ai/changelog/2026-07-18

Migma adds rename controls for campaigns, chats, series, and individual emails while preserving email subjects and keeping shared names aligned.

Adds **Rename** to campaign, chat, series, and individual email menus. Campaign names can be changed before or after sending, while individual emails keep their original subject.

A chat and its series share one name, so renaming either keeps both labels aligned.

[Visual Canvas](/creating-emails/visual-canvas) · [Campaigns](/campaigns/overview)


# Sending Metrics and Campaign Notifications
Source: https://docs.migma.ai/changelog/2026-07-19

Migma adds account-level sending metrics to the API, campaign notifications and post-send digests in Slack and Telegram, and next-campaign planning.

Adds account-level sending metrics to the Migma API. Review current-month sent, delivered, bounced, and complained totals; today's sent and reserved usage; daily and monthly limits; remaining capacity; and up to 12 previous months.

Adds campaign notifications in Slack and Telegram. Tell Migma in the current channel or chat to notify you about campaigns. Migma posts when sending starts, when a campaign is sent, or if it fails, then follows a successful send with a stats digest about 30 minutes later.

Adds next-campaign planning in Slack and Telegram. Ask what to send next and Migma answers from your Marketing Calendar: prepared campaigns with their reasons and proposed send times, plus upcoming moments worth covering. Confirm a prepared campaign in chat and Migma schedules it.

[Slack](/integrations/slack) · [Telegram](/integrations/telegram) · [API reference](/api-reference/introduction)


# CLI and agents sign in without pasting a key
Source: https://docs.migma.ai/changelog/2026-08-13

Migma adds browser-based sign-in for the CLI and coding agents through hosted MCP, migma login, or a claim code, without pasting an API key.

Adds browser sign-in for `migma login` and the same start path for coding agents: connect hosted MCP, run `migma login`, or approve a claim code. List and get MCP tools are available as soon as you are signed in.

[CLI](/cli) · [MCP Server](/mcp-server) · [Agent registration](/agent-registration)


# Agents can see email previews
Source: https://docs.migma.ai/changelog/2026-08-13-2

Migma MCP gives coding agents preview images and canvas links when listing, opening, or generating emails, with reference-image input and lighter responses.

Adds preview images when a coding agent lists, opens, or finishes generating emails through MCP. Agents can also pass reference images or an existing email when generating.

Improves those same tools so they return a canvas link and skip full HTML unless asked. Validation accepts an email id instead of raw markup. Brand list is compact and searchable.

[MCP Server](/mcp-server)


# Create API keys on any plan
Source: https://docs.migma.ai/changelog/2026-08-13-3

Migma now lets Free plan users create CI and server API keys from Settings, making API key creation available on every plan.

Adds API key creation on Free. Create a CI or server key from Settings → Developers → API Keys on any plan.

[Authentication](/authentication)


# Export emails as PNG
Source: https://docs.migma.ai/changelog/2026-08-14

Migma adds PNG export for generated emails through Publish, MCP, the SDK, and CLI, and removes MJML export in favor of HTML, PNG, or PDF.

Adds PNG image export for coding agents and the API. Export a generated email as an image from Publish, MCP, the SDK, or `migma export png`.

Removes MJML export. Use HTML, PNG, or PDF instead.

[Export options](/email-editor/export-options) · [MCP Server](/mcp-server)


# One-prompt agent setup
Source: https://docs.migma.ai/changelog/2026-08-16

Migma's Agent Setup page lets Claude Code, Codex, Cursor, and other coding agents install Migma skills, the CLI, and MCP server from one prompt.

Adds an [Agent Setup](/agent-setup) page. Paste one line into Claude Code, Codex, Cursor, or any AI coding agent, and the agent installs Migma skills, the CLI, and the MCP server itself.

[Agent Setup](/agent-setup) · [Setup](/setup)


# Adapt emails for Klaviyo's editor
Source: https://docs.migma.ai/changelog/2026-08-16-2

Migma can adapt an email for Klaviyo's editor, create the simplified template in Klaviyo, and leave the original canvas email unchanged.

Adds **Adapt for Klaviyo editor** on the Klaviyo export panel. Migma prepares a simpler version if needed, creates the template in Klaviyo, and shows **Open in Klaviyo** the same way HTML export does. The canvas email stays unchanged. **Create HTML template** still sends the original layout.

[Klaviyo](/integrations/klaviyo)


# Save brand facts from MCP
Source: https://docs.migma.ai/changelog/2026-08-17

Migma MCP agents can add and list persistent brand knowledge, including tone, products, offers, and policies, to improve later email generation.

Agents connected to Migma MCP can add and list knowledge-base entries for a brand. Lasting facts like tone, products, offers, and policies improve later email generation.

[MCP Server](/mcp-server)


# Faster CSV import and draft previews from MCP
Source: https://docs.migma.ai/changelog/2026-08-17-2

Migma MCP agents can import CSV contacts with automatic column matching and list tags, then return preview images and canvas links after generation.

Agents connected to Migma MCP can import a contact CSV in one step, with optional list tags and automatic column matching for common headers. After generating emails, agents show preview images and canvas links first, and only run inbox checks when you ask or before a send.

[MCP Server](/mcp-server) · [Manage contacts](/audience/manage-contacts) · [ChatGPT](/agents/mcp-chatgpt)


# Point at a section of an email
Source: https://docs.migma.ai/changelog/2026-08-17-3

Mark Select lets you draw over an email or reference, attach that exact section to a prompt, and direct the next Visual Canvas edit precisely.

Adds **Mark Select** in the message box, next to the visual editor. Drag a box over part of an email, like a footer, a header, or one block, then say what to do with it: "use this footer everywhere" or "make this smaller". The section you marked stays attached to your next message so edits land exactly where you pointed, not somewhere else in the email.

It works on references too. Draw over a competitor email, a saved email, or pasted HTML pinned to your canvas and ask for your own version of that part.

[Visual canvas](/creating-emails/visual-canvas)


# Managers on all brands can run the account
Source: https://docs.migma.ai/changelog/2026-08-19

Managers with access to All brands can manage sending domains, people, invites, seats, and API keys while billing remains owner-only.

Updates **Manager** on **All brands** so they can manage sending domains, People, invites, seats, and API keys. Paid seat or free collaborator does not matter.

A manager on one brand still only runs that brand. Plan and billing stay with the workspace owner.

[Team access](/collaboration/team-access) · [Sending domains](/sending-domains/overview)


# Send from your main domain
Source: https://docs.migma.ai/changelog/2026-08-19-2

Migma can send campaigns from your main domain while keeping receipts and password resets on a separate notify subdomain for reputation isolation.

Adds your main domain as the campaign sender, so recipients can see `news@yourbrand.com` with no subdomain. Receipts and password resets stay on `notify.yourbrand.com`, so a rough campaign cannot take them down.

New domains include both addresses in the DNS records shown at setup. A domain you connected earlier that still has `send.yourbrand.com` keeps that address as a marketing sender.

Sends from the main domain use your main domain's reputation for both kinds of email. The transactional address keeps receipts isolated.

[Sending Domains](/sending-domains/overview)


# DNS records and forwarding for domains bought in Migma
Source: https://docs.migma.ai/changelog/2026-08-19-3

Manage your own DNS records and domain forwarding on domains Migma hosts, for verification, receiving email, and pointing subdomains

Adds **Custom DNS records** and **Domain forwarding** to the DNS records tab for domains bought in Migma. Migma hosts DNS for these domains, and this is where you manage the zone yourself: add and remove A, AAAA, CNAME, MX, TXT, and NS records at any name under your domain. Verify the domain with another service, receive email through your inbox provider, point a subdomain at your own server, or delegate one elsewhere. You can also change where visitors land when they open your domain. Records that keep email authenticated, like SPF, DKIM, and DMARC, stay with Migma.

[Buy a Domain](/sending-domains/buy-domain)


# Agents can check credits, upgrade, and buy domains
Source: https://docs.migma.ai/changelog/2026-08-20

Migma adds API and MCP tools to inspect plan credits, open owner-approved Stripe billing links, search and buy domains, and manage custom DNS records.

Adds billing and domain purchase to the API and the Migma MCP server.

* Check the current plan and remaining email, image, and monthly credits.
* Get a Stripe checkout or billing portal link to upgrade or manage the subscription. The link is opened and approved by the account owner in a browser; the call itself charges nothing.
* Search available domains with yearly prices, buy one, and track registration until it is active. Domains renew yearly, and failed registrations are refunded automatically.
* Add and remove DNS records on domains bought in Migma, such as Google Workspace MX or site-verification TXT records. Migma's email sending records stay protected.

Adds `billing:read` and `billing:write` API key scopes. Payment always happens in the user's browser via Stripe.

[MCP Server](/mcp-server) · [API reference](/api-reference/introduction) · [Agent Auth Reference](/agent-auth)


# Clearer sending limits
Source: https://docs.migma.ai/changelog/2026-08-20-2

Migma explains sending-limit options before a campaign is sent or scheduled and labels campaigns paused by daily or monthly limits as Waiting.

Improves Campaigns when you reach today's or this month's sending limit. You can still prepare a campaign. Before send or schedule, Migma says whether to wait, send what is left today, or increase limits. A campaign that is paused at the limit now says **Waiting**.

[Send Campaign](/campaigns/send-campaign)


# Agents can convert existing HTML emails
Source: https://docs.migma.ai/changelog/2026-08-23

Migma agents can convert HTML or .eml files into editable email canvases, including multi-email series with separate email IDs and canvas links.

Adds HTML import for agents. Convert an existing HTML email or a saved `.eml` into an editable Migma email, the same way as **HTML to Email** on Create. One import can make a series. Each email is a canvas slot with its own emailId and canvas link.

[HTML to Email](/creating-emails/html-import) · [MCP Server](/mcp-server)


# Sign Up Inside the Figma Plugin
Source: https://docs.migma.ai/changelog/2026-08-23-2

Migma's Figma plugin can create an account, set a password by email, import a website brand, and learn visual patterns from previous emails.

Adds account creation inside Migma's first-party host-app clients, starting with the Figma plugin. A designer who has never used Migma can create an account in the panel instead of being sent to a registration form in another window. No password is typed into the plugin: Migma creates the account and emails a link to set one, which also confirms the address.

Adds first-run setup in the plugin. Migma offers to build your brand from your website — logo, colours and fonts — so the first converted frame already looks like your company rather than a stock template, and offers to learn your layout and tone from emails you have sent before. Both steps are optional, and skipping brand import still gives you a brand to convert into.

Fixes uploaded emails being filed as ordinary notes over the public API. `POST /v1/projects/{projectId}/knowledge-base` now keeps `previewHtml`, `thumbnailUrl`, `screenshotUrl` and `referenceOrigin`, so an email added through the API becomes a design reference the writer learns from, matching what the dashboard has always done.

Adds the Marketing Calendar to the public API. `GET /v1/projects/{projectId}/insights` returns what a brand should send next — ordered soonest first, past and already-sent campaigns omitted — each one carrying the brief that produced it, so a suggestion is one call away from a generated email. `POST`, `DELETE` and `POST .../complete` on `/insights/events` add a campaign, remove one, and mark one sent.

The Figma plugin shows the next two on its Describe tab, dated the way the dashboard dates them, and opens the full calendar from there — where campaigns can be added, removed and marked sent without leaving Figma.

Fixes missing email previews in `GET /v1/projects/emails`. The list only reported a `screenshotUrl` when one had been written by the chat path, so emails created through the API — which are screenshotted per artifact instead — came back as though they had no preview at all. The list now falls back to the artifact's thumbnail.

Adds `POST /v1/projects/sample`, which creates the demo brand for an account that has none.

[Figma import](/creating-emails/figma-import) · [Agent authentication](/agent-auth) · [API reference](/api-reference/introduction)


# Send to several segments or lists
Source: https://docs.migma.ai/changelog/2026-08-24

Migma campaigns can target several segments or several lists at once, deduplicate overlapping contacts, and block sends with no eligible recipients.

Adds multi-select on campaign Recipients and Publish for Migma sending. Pick several segments, or several lists, in one campaign. People who appear in more than one still get a single email. You cannot mix segments and lists. A selection with no eligible people still blocks send.

[Send Campaign](/campaigns/send-campaign)


# Ready Migma addresses without warmup
Source: https://docs.migma.ai/changelog/2026-08-25

Eligible new Migma accounts can use a ready managed sending address with a fixed daily limit and no warmup after verifying their email.

Updates managed Migma addresses to use their fixed daily limit without Domain Warming. Eligible new accounts can receive a ready address after email verification. Connect a domain you own when you need separate sending reputation and higher limits.

[Sending Domains](/sending-domains/overview) · [Domain warming](/sending-domains/domain-warming)


# Highlight or cover part of an image
Source: https://docs.migma.ai/changelog/2026-08-30

Visual Editor image effects now include Spotlight for dimming outside a shape and Cover area for tinting or hiding a selected region.

Adds **Effects** to **Adjust image** in the Visual Editor. Use **Spotlight** to keep one rectangle or oval clear while dimming the rest of the image. Use **Cover area** to tint or hide one selected area. Drag the area or its corners to adjust it, then choose the overlay color and strength.

[Visual Email Editor](/email-editor/visual-editor)


# Add columns in the Visual Editor
Source: https://docs.migma.ai/changelog/2026-08-31

The Visual Editor adds two-column, three-column, split, and grid blocks whose content can mix text, images, and buttons and stack on mobile.

Adds a **Columns** group to the **Add block** menu in the Visual Editor. Choose **2 columns**, **3 columns**, **1/3 + 2/3**, or **2×2 grid** to place a side by side layout, then fill each cell with text, an image, or a button. Columns stack on narrow screens, so the email still reads on a phone.

[Visual Email Editor](/email-editor/visual-editor)


# Image captions in the Visual Editor
Source: https://docs.migma.ai/changelog/2026-08-31-2

The Visual Editor now adds image captions from the image toolbar, with editable text that inherits the brand's fonts and colors.

Adds **Add caption** to the image toolbar in the Visual Editor. Select an image and choose **Add caption** to place a small line of text under it, then click it to write your own. The caption uses your brand's font and colors like any other text.

[Visual Email Editor](/email-editor/visual-editor)


# MCP clients connect without registering first
Source: https://docs.migma.ai/changelog/2026-09-03

Connect MCP clients without client registration and accept native app redirect schemes

Improves how AI clients connect to Migma over MCP. A client no longer has to register itself before the browser approval, and native apps can return to their own app scheme (for example `cursor://` or `com.example.app:/callback`) after you select **Allow**. The approval page shows the exact place the connection returns to, and the security model is unchanged: you still sign in, review the permissions, and allow the connection yourself.

Grok Bot connects through Migma's claim-code flow with a single approval link, since its cloud computer cannot receive a browser callback.

[Agent authentication](/agent-auth) · [Grok Bot](/grok)


# Connected agents keep your brand on track
Source: https://docs.migma.ai/changelog/2026-09-05

Agents connected over MCP save design references, set standing brand rules, and start from what your brand setup still needs

An agent connected to Migma over MCP now behaves like your email person from the first message. After connecting it reads your setup (brand kit, saved references, audience, sending domain) and proposes the one next step instead of listing features.

Two new tools back that up. **Save reference** stars one of your emails or stores a design you paste so future emails match it. **Update brand guidelines** writes a lasting rule (a tone, a layout habit, an image style) into the brand so every future email follows it. Migma keeps a snapshot of the previous rules before each change. The same capabilities are available in the public API and the Node SDK.

[Agent setup](/agent-setup) · [Grok Bot](/grok)


# Migma CLI Reference
Source: https://docs.migma.ai/cli

The Migma CLI wraps the full API into terminal commands. Use it for quick workflows, scripting, CI/CD pipelines, or anywhere you'd rather type than code.

The Migma CLI wraps the full API into terminal commands. Use it for quick workflows, scripting, CI/CD pipelines, or anywhere you'd rather type than code.

<CodeGroup>
  ```bash Install script theme={null}
  curl -fsSL https://install.migma.ai/cli | sh
  ```

  ```bash npm theme={null}
  npm install -g @migma/cli
  ```

  ```bash yarn theme={null}
  yarn global add @migma/cli
  ```

  ```bash pnpm theme={null}
  pnpm add -g @migma/cli
  ```

  ```bash npx (no install) theme={null}
  npx @migma/cli --help
  ```
</CodeGroup>

**Requires** Node.js 18+.

***

## Quick start

Five commands to go from zero to a sent email:

```bash theme={null}
# 1. Authenticate
migma login

# 2. Import your brand
migma projects import https://yourbrand.com --wait

# 3. Set it as default
migma projects use <projectId>

# 4. Generate an email and note the printed email ID
migma generate "Welcome email for new subscribers" --wait

# 5. Send the generated email
migma send --to sarah@example.com --email <emailId> \
  --subject "Welcome!" --from hello@yourbrand.migma.email --from-name "Your Brand"
```

***

## Authentication

```bash theme={null}
migma login
```

A browser window opens so you can sign in and approve access. The CLI stores the key locally.

Headless agents: `migma login --claim`, or fetch `https://api.migma.ai/auth.md`. CI and servers: set `MIGMA_API_KEY`.

```bash theme={null}
export MIGMA_API_KEY=your_migma_api_key
```

| Command | Description |
| - | - |
| `migma login` | Sign in with browser OAuth |
| `migma login --claim` | Approve a one-time code instead |
| `migma login --api-key` | Paste an existing key |
| `migma logout` | Remove stored credentials |
| `migma whoami` | Show current key and default project |

***

## Generate

Create on-brand emails with AI from a single command.

```bash theme={null}
migma generate "Summer sale — 30% off everything" --wait
```

| Flag | Effect |
| - | - |
| `--wait` | Block until generation completes |
| `--save <file>` | Save the finished HTML locally (requires `--wait`) |
| `--open` | Open the result in your browser (requires `--wait`) |
| `--image <url>` | Attach a reference image to the prompt |
| `--reference <id>` | Remix from an existing conversation ID |
| `--count <n>` | Request a specific number of emails for a series |

<Tip>
  Chain with validate: `migma generate "..." --wait && migma validate all --conversation <conversationId>`
</Tip>

Create a series and save each email as a separate HTML file:

```bash theme={null}
migma generate "Three-email onboarding series for new trial users" --count 3 --wait --save ./onboarding.html
```

When a generation returns multiple emails, `--save ./onboarding.html` writes `onboarding-1.html`, `onboarding-2.html`, and so on. The status output also lists each email ID, which you use to fetch, edit, or send that email.

Check on a running generation:

```bash theme={null}
migma generate-status <conversationId>
```

***

## Send

Send to an individual, a segment, or a tag. Emails send through Migma by default — you can also connect [external providers](/integrations/email-service-providers).

<CodeGroup>
  ```bash Individual theme={null}
  migma send \
    --to sarah@example.com \
    --email email_abc123 \
    --from hello@yourbrand.migma.email \
    --from-name "Your Brand" \
    --subject "Your discount inside"
  ```

  ```bash To a segment theme={null}
  migma send \
    --segment seg_vip \
    --email email_abc123 \
    --subject "Exclusive VIP Offer" \
    --from hello@yourbrand.migma.email \
    --from-name "Your Brand"
  ```
</CodeGroup>

Use `--email` with the email ID returned by generation status or selected in the editor, especially multi-slot emails and series. `--from-conversation` works for single-email conversations.

| Command | Description |
| - | - |
| `migma send-test --email <emailId> --to <email>` | Send a test email |
| `migma batch-status <batchId>` | Check batch delivery progress |

<Tip>
  Add `--idempotency-key <key>` to `send` to make a retry safe: sending the same key with the same body within 24 hours replays the original response instead of sending twice. Use a deterministic key you can reproduce on retry (for example `send-<emailId>-<recipient>`), never a random value or timestamp.
</Tip>

***

## Validate

Run [preflight checks](/email-editor/email-preflight) before you send.

```bash theme={null}
migma validate all --html ./email.html
```

| Check | What it does |
| - | - |
| `migma validate all` | Run every check, show overall score |
| `migma validate compatibility` | Compatibility report for major email clients (score out of 100) |
| `migma validate links` | Find broken links |
| `migma validate spelling` | Grammar and spelling |
| `migma validate deliverability` | Spam score and inbox prediction |

All commands accept `--html <file>` or `--conversation <id>`.

***

## Export

Export generated emails to files or platforms. See [export options](/email-editor/export-options) for details on each format.

```bash theme={null}
# Save HTML locally
migma export html conv_abc123 --output ./email.html

# Export for Klaviyo
migma export klaviyo conv_abc123 --type hybrid
```

| Format | Command |
| - | - |
| HTML | `migma export html <id>` |
| PNG | `migma export png <id>` |
| PDF | `migma export pdf <id>` |
| Klaviyo | `migma export klaviyo <id>` |
| Mailchimp | `migma export mailchimp <id>` |
| HubSpot | `migma export hubspot <id>` |

All export commands support `--output <file>` to download the result locally.

***

## Campaigns

Create and manage marketing campaigns with lifecycle tracking (create, schedule, send, cancel).

<Note>
  **Campaigns vs `migma send`:** Use `migma send` for quick fire-and-forget sends (transactional emails, one-off blasts). Use `migma campaigns` when you need a named, trackable campaign tied to a project — with scheduling, status tracking, and recipient counts.
</Note>

```bash theme={null}
# Create a campaign from a generated email
migma campaigns create --project <projectId> \
  --name "Investor Update" --conversation <conversationId> --email <emailId> \
  --from hello@company.migma.email --from-name "Company" \
  --recipient-type tag --recipient-id <tagId>

# Send immediately
migma campaigns send <campaignId>

# Or schedule for later
migma campaigns schedule <campaignId> --at "2026-03-15T14:00:00Z" --timezone "America/New_York"

# Cancel a scheduled campaign
migma campaigns cancel <campaignId>

# Engagement stats and per-recipient delivery logs
migma campaigns stats <campaignId>
migma campaigns logs <campaignId> --status bounced --limit 50
```

| Command | Description |
| - | - |
| `migma campaigns list` | List campaigns for a project |
| `migma campaigns create --name <name> --conversation <conversationId> --email <emailId> --from <email> --from-name <name> --recipient-type tag --recipient-id <id>` | Create a campaign from a generated email |
| `migma campaigns get <id>` | Get campaign details |
| `migma campaigns send <id>` | Send a campaign immediately |
| `migma campaigns schedule <id> --at <datetime>` | Schedule for future delivery |
| `migma campaigns cancel <id>` | Cancel a scheduled campaign |
| `migma campaigns stats <id>` | Engagement stats (sent, delivered, opens, clicks, bounces, rates) |
| `migma campaigns logs <id> [--status <s>] [--limit <n>] [--cursor <c>]` | Per-recipient delivery logs, cursor-paginated |

`campaigns logs` accepts `--status` (`delivered`, `opened`, `clicked`, `bounced`, `spam_report`), `--limit` (1-100), and `--cursor` for the next page. Stats come from the tracking worker and may be slightly stale; `botOpens`, `botClicks`, and `mppOpens` reflect Apple Mail Privacy Protection and bot detection when available.

<Tip>
  `campaigns create`, `campaigns send`, and `campaigns schedule` all accept `--idempotency-key <key>` for safe retries. The same key with the same body within 24 hours replays the original response. For campaign sends, a deterministic key like `campaign-send-<campaignId>` prevents a retried send from going out twice. Don't use a random value or timestamp.
</Tip>

***

## Emails

List, import HTML, fetch, and prompt-edit your generated emails.

```bash theme={null}
migma emails list --project <projectId>
migma emails import-html ./welcome.html --wait
migma emails get <emailId> --output ./email.html
migma emails edit <emailId> --prompt "Make this welcome email shorter" --output ./email.html
migma emails metrics <emailId>
migma emails logs <emailId> --status opened --limit 50
```

| Command | Description |
| - | - |
| `migma emails list` | List emails for a project (paginated) |
| `migma emails import-html [files...]` | Convert existing HTML or `.eml` files into editable emails |
| `migma emails get <emailId>` | Get one generated email with production HTML |
| `migma emails edit <emailId> --prompt <text>` | Prompt Migma to edit one generated email |
| `migma emails metrics <emailId>` | Performance for one generated email across its API sends (delivery, opens, clicks, bounces, rates) |
| `migma emails logs <emailId> [--status <s>] [--limit <n>] [--cursor <c>]` | Per-recipient send log for one generated email, cursor-paginated |

`emails logs` accepts `--status` (`delivered`, `opened`, `clicked`, `bounced`, `complained`, `suppressed`, `sent`), `--limit` (1-100), and `--cursor` for the next page. Stats come from the tracking worker and may be slightly stale; opens are directional (Apple Mail Privacy Protection and bots inflate them) while clicks and delivery are stronger signals.

| Flag | Effect |
| - | - |
| `--limit <n>` | Max results (1-100, default 20) |
| `--status <status>` | Filter by status (`pending`, `processing`, `completed`, `failed`) |
| `--search <query>` | Search by title or subject |

***

## Audience

<AccordionGroup>
  <Accordion title="Contacts" icon="address-book">
    | Command | Description |
    | - | - |
    | `migma contacts list` | List contacts (paginated) |
    | `migma contacts add --email <email> --status subscribed` | Create a contact |
    | `migma contacts get <id>` | Get contact details |
    | `migma contacts update <id> --first-name Jane` | Update a contact |
    | `migma contacts remove <id>` | Delete a contact |
    | `migma contacts import ./file.csv` | Bulk import from CSV |

    The CSV importer auto-detects common column names (`email`, `firstName`, `first_name`, `First Name`, etc.). Any unrecognized columns become custom fields.

    `contacts add` accepts `--idempotency-key <key>` so a retried create won't duplicate the contact: the same key with the same body within 24 hours replays the original response. A deterministic key like `contact-<email>` works well.
  </Accordion>

  <Accordion title="Tags" icon="tag">
    | Command | Description |
    | - | - |
    | `migma tags list` | List all tags |
    | `migma tags create --name "VIP"` | Create a tag |
    | `migma tags delete <id>` | Delete a tag |
  </Accordion>

  <Accordion title="Segments" icon="layer-group">
    | Command | Description |
    | - | - |
    | `migma segments list` | List all segments |
    | `migma segments create --name "Active" --description "..."` | Create a segment |
    | `migma segments create --name "Campaign openers" --filters '{"activity":[{"action":"opened","channel":"email","mode":"within","unit":"days","amount":14,"campaignId":"cmp_123"}]}'` | Create an activity or campaign-scoped segment |
    | `migma segments get <id>` | Get segment details |
    | `migma segments delete <id>` | Delete a segment |
  </Accordion>
</AccordionGroup>

***

## Infrastructure

<AccordionGroup>
  <Accordion title="Projects" icon="building">
    | Command | Description |
    | - | - |
    | `migma projects list` | List all projects (`--all` for every page) |
    | `migma projects get <id>` | Get project details |
    | `migma projects import <url>` | Import brand from URL (`--wait` to block) |
    | `migma projects use <id>` | Set default project |
  </Accordion>

  <Accordion title="Domains" icon="globe">
    ```bash theme={null}
    # Instant managed domain (no DNS — see /sending-domains/overview)
    migma domains managed create mycompany

    # Custom domain
    migma domains add mail.yourbrand.com
    migma domains verify mail.yourbrand.com

    # Transactional stream (notify.yourbrand.com) to isolate reputation
    migma domains streams create yourbrand.com --stream transactional
    ```

    | Command | Description |
    | - | - |
    | `migma domains list` | List sending domains |
    | `migma domains add <domain>` | Add a custom domain |
    | `migma domains verify <domain>` | Verify DNS records |
    | `migma domains managed create <prefix>` | Create instant subdomain |
    | `migma domains managed delete <domain>` | Delete managed subdomain |
    | `migma domains streams create <rootDomain> --stream <type>` | Provision a transactional or marketing stream |
  </Accordion>

  <Accordion title="Events & Webhooks" icon="bolt">
    | Command | Description |
    | - | - |
    | `migma webhooks list` | List all webhooks |
    | `migma webhooks create --url <url> --events <events...>` | Create a webhook |
    | `migma webhooks test <id>` | Send a test event |
    | `migma webhooks delete <id>` | Delete a webhook |
  </Accordion>
</AccordionGroup>

***

## Options

The root CLI accepts `--json`, and most project-scoped commands accept `--project <id>`:

| Flag | Description |
| - | - |
| `--json` | Machine-readable JSON output |
| `--project <id>` | Override the default project on project-scoped commands |
| `--help` | Show help for any command |

```bash theme={null}
# Pipe JSON into jq
migma contacts list --json | jq '.contacts[].email'
```

***

## Configuration

The CLI stores config in `~/.migma/config.json`:

| Setting | Priority |
| - | - |
| **API key** | `MIGMA_API_KEY` env var → config file |
| **Project ID** | `--project` flag → `MIGMA_PROJECT_ID` env var → config file |

***

## Common workflows

<Steps>
  <Step title="Generate → Validate → Send">
    ```bash theme={null}
    migma generate "Black Friday — 40% off everything" --wait
    migma validate all --conversation <conversationId>
    migma send --to test@yourbrand.com --from-conversation <conversationId> \
      --from hello@yourbrand.migma.email --from-name "Your Brand" \
      --subject "Black Friday Sale"
    migma send --segment seg_vip --email <emailId> \
      --from hello@yourbrand.migma.email --from-name "Your Brand" \
      --subject "Black Friday Sale"
    ```
  </Step>

  <Step title="Import → Generate → Export to Klaviyo">
    ```bash theme={null}
    migma projects import https://yourbrand.com --wait
    migma projects use <projectId>
    migma generate "Monthly newsletter" --wait
    migma export klaviyo <conversationId>
    ```
  </Step>

  <Step title="CSV import → Tag → Send">
    ```bash theme={null}
    migma contacts import ./subscribers.csv
    migma tags create --name "Launch List"
    migma send --tag <tagId> --email <emailId> \
      --from hello@yourbrand.migma.email --from-name "Your Brand" \
      --subject "We're live!"
    ```
  </Step>
</Steps>

***

<CardGroup>
  <Card title="npm" icon="npm" href="https://www.npmjs.com/package/@migma/cli">
    View on npm
  </Card>

  <Card title="Node.js SDK" icon="code" href="/sdk">
    Use the SDK in your apps
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Full endpoint docs
  </Card>
</CardGroup>


# Agencies & Client Brands
Source: https://docs.migma.ai/collaboration/agencies

Agencies don't need a special mode. Running client work uses the same pieces as any team: a workspace for billing and membership, per-brand roles, and invites.

Agencies don't need a special mode. Running client work uses the same pieces as any team: a [workspace](/collaboration/workspaces) for billing and membership, [per-brand roles](/collaboration/team-access), and invites. There are two common setups, depending on who owns the brand.

<Note>
  A brand always lives in one workspace. You collaborate by inviting people into the workspace that owns the brand, not by sharing one brand across two separate accounts.
</Note>

## Agency of Record

The agency owns the work. You run a workspace, keep each client's brands inside it, and invite the client in to review.

* Your staff get **Editor** or **Manager** roles, which use a paid seat, or join as [free collaborators](/collaboration/seats#free-collaborators) without one. See [Seats](/collaboration/seats).
* Each client gets **Viewer** or **Commenter** on their own brand, so they can review and approve. Those roles use no seat.
* **Who pays:** the agency's account. Clients cost nothing to add.

Keep one workspace per client when you want their brands, members, and review kept separate. Switch between them from the workspace switcher, covered in [Workspaces](/collaboration/workspaces).

<Steps>
  <Step title="Create a workspace for the client">
    From the workspace switcher, create a new workspace named for the client.
  </Step>

  <Step title="Add the client's brands">
    Build or import the client's brand inside that workspace.
  </Step>

  <Step title="Invite your team as editors">
    Invite the staff working on the account as **Editor**, or **Manager** if they should also manage members and settings.
  </Step>

  <Step title="Invite the client to review">
    Invite the client's stakeholders as **Viewer** or **Commenter** on their brand. They can follow along and approve without taking a seat.
  </Step>
</Steps>

<Check>
  Only **managers** and the account owner can invite members. As the agency owner you have manager access to every brand automatically.
</Check>

***

## Guest on a Client's Brand

Here the client owns the brand in their own workspace and brings the agency in to help.

* The client invites your team from the brand's **Share** panel, brand by brand. See [Team Access](/collaboration/team-access).
* Your **Editors** and **Managers** use the client's seats. **Viewers** and **Commenters** are free.
* **Who pays:** the brand owner's account. The client funds the seats for the agency members who edit.

<Tip>
  If the client only needs you to review or hand off feedback, ask for **Commenter**. It keeps you out of their seat count.
</Tip>

***

## Choosing a Setup

| Setup | Who owns the brands | Who pays | Best for |
| - | - | - | - |
| Agency of record | The agency | The agency | Running client accounts end to end |
| Guest on a client's brand | The client | The client | Helping on a brand the client owns |
| Stakeholder review | Either | No one, it's free | Approvals and feedback, no editing |

***

## Common Questions

<AccordionGroup>
  <Accordion title="Can someone edit a brand without using a seat?" icon="chair">
    Yes. The workspace owner or a manager on all brands can invite an editor or manager as a **free collaborator**: full editing and live collaboration, no seat, with AI generation running on the collaborator's own plan's credits. For review only, **Viewer** or **Commenter** access stays the simplest option. See [Free collaborators](/collaboration/seats#free-collaborators).
  </Accordion>

  <Accordion title="Can two companies co-own the same brand?" icon="building">
    A brand lives in one workspace. Invite the other company's people into that workspace, brand by brand, as guests. The workspace owner's account covers their seats.
  </Accordion>

  <Accordion title="Does a client need a paid plan to review or comment?" icon="eye">
    No. **Viewer** and **Commenter** access is free and never uses a seat, on any plan.
  </Accordion>
</AccordionGroup>

***

## Related

<CardGroup>
  <Card title="Team Access" icon="users" href="/collaboration/team-access">
    The four roles and how to invite people to a brand.
  </Card>

  <Card title="Seats" icon="chair" href="/collaboration/seats">
    Which roles use a seat and who gets billed.
  </Card>

  <Card title="Workspaces" icon="building" href="/collaboration/workspaces">
    The billing and membership boundary, and the switcher.
  </Card>
</CardGroup>


# Multiple Brands
Source: https://docs.migma.ai/collaboration/multiple-brands

Organize multiple companies, stores, clients, product lines, or sender identities as separate Migma brands, with the right workspace and team access.

Use multiple brands when you manage more than one company, store, client, product line, or sender identity. Each brand keeps its own visual system, voice, assets, contacts, emails, campaigns, and sending setup.

<Info>
  In the API, brands are called projects. Public docs use **brand** because that is the user-facing product term.
</Info>

***

## Brand or workspace?

| Use | Best fit | Why |
| - | - | - |
| Same company, different product line | Separate brand in one workspace | Shared billing and team, separate design and sending context |
| Agency managing client work | One workspace per client, or one agency workspace with brands per client | Pick based on billing ownership and access separation |
| Different legal entity or billing owner | Separate workspace | Billing, seats, members, and sending quota stay separate |
| Same team testing a new sender identity | Separate brand | Clean brand kit, sender, audience, and campaign history |

See [Workspaces](/collaboration/workspaces) when billing or membership should be separate.

***

## What stays separate

* Brand kit: logo, colors, fonts, voice, products, and design rules.
* Sending setup: verified sending domains and sender identity.
* Audience: contacts, tags, segments, topics, and suppression.
* Emails and campaigns: drafts, series, campaign history, and analytics.
* Access: people can be invited to one brand, selected brands, or all brands.

***

## Set up another brand

<Steps>
  <Step title="Create the brand">
    Open **My Brands**, choose **New Brand**, then import from a website or configure the brand manually.
  </Step>

  <Step title="Review the brand kit">
    Confirm logo, colors, fonts, tone, and product context before generating emails.
  </Step>

  <Step title="Add sending setup">
    Verify a sending domain or connect the provider that should send for that brand.
  </Step>

  <Step title="Invite collaborators">
    Use **Share** for one brand, or **Settings → People** for selected brands or all brands.
  </Step>
</Steps>

***

## Related

<CardGroup>
  <Card title="Brand setup" icon="palette" href="/get-started/configure-brand">
    Import and tune one brand kit.
  </Card>

  <Card title="Workspaces" icon="building" href="/collaboration/workspaces">
    Decide where billing, seats, and sending quota live.
  </Card>

  <Card title="Team access" icon="users-viewfinder" href="/collaboration/team-access">
    Invite people to one brand, selected brands, or all brands.
  </Card>

  <Card title="Agencies" icon="briefcase" href="/collaboration/agencies">
    Structure client work.
  </Card>
</CardGroup>


# Workspaces, Seats & Real-Time
Source: https://docs.migma.ai/collaboration/overview

A workspace is where billing, members, seats, brands, and sending limits come together. Seats decide who can edit on Business.

A **workspace** is where billing, members, seats, brands, and sending limits come together. **Seats** decide who can edit on Business. **Real-time collaboration** starts automatically when teammates open the same brand.

Use this page as the hub, then open the detailed page you need:

<CardGroup>
  <Card title="Workspaces" icon="building" href="/collaboration/workspaces">
    Personal vs team workspace, active workspace switcher, shared credits, and owner billing.
  </Card>

  <Card title="Team access" icon="users-viewfinder" href="/collaboration/team-access">
    Share panel invites per brand. The People settings for account-wide invites. Manager, Editor, Commenter, Viewer.
  </Card>

  <Card title="Seats" icon="chair" href="/collaboration/seats">
    Business plan editor seats. Commenters and viewers are free. Two seats included; add more as you grow.
  </Card>

  <Card title="Real-time collaboration" icon="satellite-dish" href="/collaboration/realtime">
    Presence, live cursors, slot focus, canvas refresh, and generation awareness when two editors are online.
  </Card>
</CardGroup>

***

## How it works

| Area | What it controls | Where to manage it |
| - | - | - |
| Workspace | Billing owner, active plan, shared brands, sending quota | Profile menu and **Settings → Billing** |
| Brand access | Who can open, edit, comment, or view a brand | **Share** panel or **Settings → People** |
| Seats | Which Business collaborators get paid editor access | **Settings → People** |
| Real-time | Presence, cursors, canvas sync, and generation awareness | Automatic on shared brands |

***

## Common setups

**Solo workspace**

You own brands, credits, and billing. No seats needed unless you upgrade to Business and invite editors.

**In-house team**

One team workspace. Owner pays. Editors use seats; stakeholders join as Commenter or Viewer on each brand. Open a brand and work live on the [visual canvas](/creating-emails/visual-canvas).

**Agency**

One workspace per client (or one workspace for your agency with brands per client). Clients review without seats. See [Agencies & client brands](/collaboration/agencies).

***

## Related

* [Where to edit your email](/email-editor/editing-your-email): chat, visual editor, and canvas while collaborating
* [Billing and plans](/get-started/billing-and-plans): Premium, Business, seats, and workspace billing


# Real-Time Collaboration
Source: https://docs.migma.ai/collaboration/realtime

Collaborate in Migma with live teammate presence, shared cursors, instant canvas updates, comments, and conflict-safe editing across the same project.

When two or more people open the same project, Migma turns it into a live room. You see who else is here, watch their cursors move across shared project surfaces, and see edits appear as they make them. Nothing to switch on, nothing to refresh.

<Note>
  Real-time presence and cursors are **ephemeral**. They show who's active right now and where they're pointing; they are never written to your project. The durable work — your emails, canvas, and project data — is saved the same way it always is.
</Note>

***

## What you get

<CardGroup>
  <Card title="Live presence" icon="users">
    See everyone currently in the project as a stack of avatars.
  </Card>

  <Card title="Live cursors" icon="arrow-pointer">
    Watch teammates' pointers move across shared project surfaces in real time.
  </Card>

  <Card title="Slot focus" icon="crosshairs">
    See which series slot a collaborator has open and is editing.
  </Card>

  <Card title="Generation awareness" icon="wand-magic-sparkles">
    A live "X is generating…" indicator so two people don't run the AI on the same email at once.
  </Card>

  <Card title="Comment threads" icon="comments">
    Leave anchored feedback, mention teammates, reply in place, and resolve or reopen each thread.
  </Card>
</CardGroup>

***

## Live presence

The avatar stack in the project header shows who else is in the room right now. As people join and leave, the stack updates instantly — no reload. Each collaborator gets a stable color so you can tell their cursor and focus apart from everyone else's.

<img alt="A stack of collaborator avatars in the project header showing who is currently in the room" title="Live presence avatar stack" />

When more people are present than fit, the stack collapses the extras into a `+N` bubble. Presence only ever shows signed-in collaborators with access — anonymous public-link viewers never appear and never leak into the room.

***

## Live cursors and slot focus

Move your pointer in chat or over a shared project surface and everyone else in the room sees it, labelled with your name and color. In canvas views, cursors travel in canvas coordinates, so they stay anchored to the right spot even as people pan and zoom independently.

<img alt="Two labelled teammate cursors shown inside the Migma chat composer" title="Live cursors in chat" />

For series emails, Migma also broadcasts **slot focus** — which slot in a multi-email series each person currently has open. That makes it obvious when a teammate is already working on slot 3 while you're in slot 1.

<Tip>
  Cursors and focus are best-effort and fire-and-forget. If the network hiccups, a few frames may drop and then catch back up — they're never queued or replayed, so you always see the latest position rather than a stale backlog.
</Tip>

***

## Live canvas sync

When a collaborator changes the canvas, pins a competitor email, adds a comment, or moves a node, everyone else's canvas shows the change within a moment. Migma coalesces rapid bursts such as dragging into one refresh, so the canvas stays smooth instead of flickering.

This is a refresh-on-change model: peers receive a small "the canvas changed" ping and re-pull the latest state. There's no character-by-character merging on the underlying email in this version — the most recent change to a given area wins.

***

## Comment threads

Select the comment tool on **Visual Canvas**, then choose a point beside the email or canvas area you want to discuss. The thread opens at that point. Type `@` or use the `@` button to find a teammate by name or email in new comments and replies. The selected teammate gets an in-app alert that returns them to the exact thread, even if they were away when you tagged them.

Comment markers show the original author and reply count without covering the work. Commenters can use threads without gaining permission to edit emails or send campaigns. Viewers can read existing threads.

Unresolved thread text is available to Migma on the next design turn. Resolving a thread keeps it visible for your team but removes it from later design context.

***

## Generation awareness

Running the AI agent is the one action where two people genuinely collide. To prevent that, Migma shows a live indicator when someone is generating.

<img alt="A live indicator reading 'Alex is generating' shown while a teammate runs the AI agent" title="Live generation indicator" />

While a generation is in flight, you can see who's running it. If you try to start your own run on a locked email, Migma holds you off and shows who currently holds the turn, rather than letting two AI runs stomp on the same email.

***

## How it turns on

<Steps>
  <Step title="Open a shared project">
    Real-time is automatic. The moment a project has collaborators with access, the live room is available.
  </Step>

  <Step title="A teammate joins">
    When someone else opens the same project, you both appear in each other's presence stack.
  </Step>

  <Step title="Work together">
    Cursors, slot focus, canvas changes, and generation status all flow live for as long as you're both there.
  </Step>
</Steps>

<Check>
  There's no setting to enable and nothing to install. If you don't see anyone else, it just means you're the only person in the project right now.
</Check>

***

## What real-time does and doesn't do

<AccordionGroup>
  <Accordion title="Is my work saved by real-time?" icon="floppy-disk">
    No — and it doesn't need to be. Presence and cursors are ephemeral signals about who's active. Your actual emails and canvas are saved through the normal project flow, independent of the live room.
  </Accordion>

  <Accordion title="What happens if I lose connection?" icon="wifi">
    Your cursor and presence simply stop broadcasting until you reconnect. On reconnect, you re-pull the current project state — you never replay a backlog of missed cursor frames.
  </Accordion>

  <Accordion title="Can public-link viewers see presence?" icon="eye-slash">
    No. Anonymous viewers get the read-only render path with no real-time room, so presence and cursors never leak to people without access.
  </Accordion>

  <Accordion title="Do edits merge character by character?" icon="code-merge">
    Not in this version. Canvas sync is refresh-on-change and manual text edits to the same area resolve last-write-wins. There's no operational-transform merge on the email content yet.
  </Accordion>
</AccordionGroup>

<Note>
  Comment replies and resolution changes use the same canvas sync as other durable nodes. Teammates see the saved thread update within a moment.
</Note>

***

## Related pages

<CardGroup>
  <Card title="Workspaces" icon="building" href="/collaboration/workspaces">
    Team workspace switcher and shared credits.
  </Card>

  <Card title="Team Access" icon="users-viewfinder" href="/collaboration/team-access">
    Invite collaborators and control who can view or edit a brand.
  </Card>

  <Card title="Visual Canvas" icon="diagram-project" href="/creating-emails/visual-canvas">
    The shared canvas where presence, cursors, and live sync come together.
  </Card>
</CardGroup>


# Seats & Team Billing
Source: https://docs.migma.ai/collaboration/seats

On the Business plan, a seat is a paid slot for someone who edits: generate emails, change designs, send campaigns. Commenters and viewers do not use seats.

On the **Business** plan, a **seat** is a paid slot for someone who **edits**: generate emails, change designs, send campaigns. **Commenters** and **viewers** do not use seats. You pay per editor, not per brand.

You can also invite an editor as a **free collaborator**: they edit and collaborate without using a seat, and their AI generation runs on their own plan's credits instead of Premium-level limits. See [Free collaborators](#free-collaborators).

<Note>
  Seats apply to the **Business** plan. Roles are in [Team access](/collaboration/team-access). Workspaces and shared credits are in [Workspaces](/collaboration/workspaces).
</Note>

***

## Who uses a seat

| Role | Uses a seat? |
| - | :-: |
| Owner / Admin / Manager | Yes |
| Editor | Yes |
| Editor or Manager invited as free collaborator | No |
| Commenter | No |
| Viewer | No |

One person uses **one seat** across every brand they can edit in that workspace.

<Tip>
  Invite stakeholders as **Commenter** or **Viewer** when they only review.
</Tip>

***

## Free collaborators

A **free collaborator** is an editor or manager who holds no seat. They get the full collaboration experience: live editing, canvas sync, sending from the brand. The difference is AI generation, which runs on **their own plan's credits**. A seat is what grants a collaborator Premium-level generation.

* The workspace **owner** or a **manager on all brands** (paid or free) can choose this at invite time: check **Free collaborator** when inviting an editor or manager, from a brand's Share panel or from **Settings → People**.
* You can also switch someone **after** they've joined. In **Settings → People**, open the row menu next to their name and choose **Make free collaborator** — or **Assign paid seat** to move them back onto the seat bill.
* A free collaborator who is a **manager** can invite others, and everyone they invite is a free collaborator too. Their whole invited group stays off your seat bill.
* There is no limit on free collaborators.

<Note>
  A free collaborator never converts into a paid seat on its own. Role changes, new brand grants, and re-invites keep them seat-free until the owner or a manager on all brands assigns a paid seat.
</Note>

***

## Included and extra seats

Business includes **2 seats**. Add more from **Settings → People** or during Business checkout. Extra seats bill monthly (prorated when you change mid-cycle).

<Steps>
  <Step title="Open Settings → People">
    Seat purchase controls appear when the workspace is on Business and you are the owner.
  </Step>

  <Step title="Adjust seat count">
    Use the stepper. The UI shows included vs extra seats and the price before you confirm.
  </Step>

  <Step title="Confirm">
    New seats are available after checkout succeeds.
  </Step>
</Steps>

<img alt="Seat management with count stepper and price preview" title="Manage seats" />

<Check>
  Only the workspace **owner** can buy extra seats or change billing. A **manager on all brands** can invite people and move someone between a paid seat and a free collaborator.
</Check>

***

## Free a seat

Change an editor to **Viewer** or **Commenter**, or remove them. The seat frees immediately. Lower your purchased seat count after editors are off seats if you want a smaller bill.

***

## Who is billed

Subscription and seat charges go to the **workspace owner**. Admins can manage people and seats; invoices stay on the owner account.

AI generation is per person: a **seat holder** generates with Premium-level limits on their own account, and a **free collaborator** generates on their own plan's credits. Campaign **sending** uses the workspace owner's quota, since campaigns send from the owner's domain (see [Workspaces](/collaboration/workspaces)).

***

## Related

<CardGroup>
  <Card title="Workspaces" icon="building" href="/collaboration/workspaces">
    Switch workspace and shared credits.
  </Card>

  <Card title="Team access" icon="users" href="/collaboration/team-access">
    Invite and roles.
  </Card>

  <Card title="Real-time collaboration" icon="bolt" href="/collaboration/realtime">
    Live editing on a brand.
  </Card>
</CardGroup>


# Team Access
Source: https://docs.migma.ai/collaboration/team-access

Migma is built for teams. Invite a teammate to a brand, pick a role, and the server enforces that role on generate, send, comment, and settings actions.

Migma is built for teams. Invite a teammate to a **brand**, pick a role, and the server enforces that role on generate, send, comment, and settings actions.

Workspaces control billing and shared credits; see [Workspaces](/collaboration/workspaces). Paid **editor seats** on Business are in [Seats](/collaboration/seats).

<Note>
  If you own or admin the account, you already have **manager** access to every brand — you don't need to invite yourself. The owner is treated as a manager everywhere.
</Note>

## The four roles

When you invite someone, you pick one role for the brand. Each role is a fixed set of permissions.

| What they can do | Manager | Editor | Commenter | Viewer |
| - | :-: | :-: | :-: | :-: |
| View emails and brand assets | ✓ | ✓ | ✓ | ✓ |
| Comment and leave feedback | ✓ | ✓ | ✓ | — |
| Generate and edit emails | ✓ | ✓ | — | — |
| Upload images | ✓ | ✓ | — | — |
| Send campaigns | ✓ | ✓ | — | — |
| Manage brand settings | ✓ | — | — | — |
| Invite and manage members | ✓ | — | — | — |
| Manage sending domains and People (all brands only) | ✓ | — | — | — |

In short:

* **Manager on all brands** — runs the account and collab: sending domains, People, invites, seats, and API keys. Paid or free collaborator does not matter. Plan and billing stay with the owner.
* **Manager on one brand** — runs that brand only, including members and sending from a ready domain. Cannot change account sending domains.
* **Editor** — generates, edits, and sends emails, but can't manage members or brand settings.
* **Commenter** — can view and leave feedback, but can't change or send anything.
* **Viewer** — read-only.

On **Visual Canvas**, commenters can place anchored comments, mention active teammates, reply to threads, move comment markers, and resolve or reopen feedback. They cannot change email content, generate, publish, or send.

<Tip>
  Pick the lowest role that lets someone do their job. You can give a stakeholder **viewer** or **commenter** access for review without risking an accidental send, and bump them up later.
</Tip>

<Note>
  Inviting an **Editor** or **Manager** normally uses a paid seat. The workspace owner or a manager with access to all brands can instead check **Free collaborator** on the invite: they edit and collaborate without a seat, and their AI generation runs on their own plan's credits. See [Free collaborators](/collaboration/seats#free-collaborators).
</Note>

***

## Invite a teammate to a brand

The quickest way to add someone to a single brand is the **Share** panel, right where you're working.

<Steps>
  <Step title="Open Share">
    Inside the brand, open the **Share** panel from the collaboration controls.
  </Step>

  <Step title="Enter their email">
    Type the teammate's email address.
  </Step>

  <Step title="Pick a role">
    Choose **Manager**, **Editor**, **Commenter**, or **Viewer**. Editor is the default.
  </Step>

  <Step title="Send the invite">
    Send it. They get an email invitation and appear under pending invites until they accept.
  </Step>
</Steps>

<img alt="The Share panel with an email field, a role picker, and the list of people who already have access" title="Invite a teammate with a role" />

<Check>
  Only **managers** (and the account owner) can invite or remove members. If you don't see the invite controls, you don't have manager access on that brand.
</Check>

***

## Invite across all your brands at once

If a teammate should work across everything, you can invite them at the account level instead of brand by brand. Go to **Settings → People**, select **Invite members**, enter their email, pick a role, and leave the access set to **All brands**.

When they accept, they get that role on **every** brand you own — current and future — so you don't have to re-invite them each time you create a new brand. Switch the access to **Specific brands** to invite one person to several brands in a single step, and tick **Invite as a free collaborator** to bring them in without using a seat.

<Check>
  The workspace **owner** or a **manager on all brands** can open **Settings → People**. A manager on one brand invites from that brand's **Share** panel instead.
</Check>

***

## Manage members and pending invites

**Settings → People** has two views: **People** for everyone in the workspace, and **Brand access** for a brand-by-brand breakdown.

### Pending invitations

Invitations that haven't been accepted yet sit in their own panel **above** the people list, so you don't have to go looking for them. Each row shows the invited email, what they'll get access to, their role, whether the invite reserves a seat, and when it was sent. Expired invites are flagged.

The row menu lets you **copy the invite link**, **resend the email**, or **revoke** the invitation. The whole panel disappears once nothing is pending.

<img alt="The pending invitations panel listing an invited email, what it grants access to, the role and seat impact, and when it was sent, with one invite flagged as expired" title="Pending invitations" />

### People

Everyone who has accepted, with their role, their reach (all brands, a count of specific brands, or owner), when they joined, and their credit usage this month against their limit.

* **Search** matches name, email, role, reach, and seat status — so typing `free` narrows the list to your free collaborators.
* **Filter by role** — Owner, Manager, Editor, Commenter, or Viewer.
* **Change a role** — for someone with all-brands access, switch them between Manager, Editor, Commenter, and Viewer inline.
* **Row menu** — copy their email address, move them between a paid seat and a [free collaborator](/collaboration/seats#free-collaborators), or remove their workspace access.

<img alt="The people list showing each member's role, reach, seat status, join date and credit usage, above a search field and role filter" title="The people list" />

### Act on several people at once

Hover someone's avatar and a checkbox appears in its place. As soon as anything is selected, a bar appears at the bottom of the screen — and the toolbar's **Export** button switches to exporting just your selection:

* **Export** — download the selected people as a CSV.
* **Remove access** — remove everyone selected, after a confirmation.

Some people can't be removed here: the workspace owner, admins, and you. If your selection includes them, the confirmation tells you how many are being skipped and removes only the rest.

<img alt="Two people selected in the roster, with a floating bar at the bottom offering Export and Remove access" title="Acting on a selection" />

<Note>
  **Export** with nothing selected downloads every person in the workspace plus any pending invitations.
</Note>

Per-brand members and their pending invites can also be managed from that brand's **Share** panel.

***

## How access is enforced

Roles aren't just a UI hint. Every sensitive action — generating an email, sending a campaign, leaving a comment, managing members — is checked against the user's role on the server before it runs.

<AccordionGroup>
  <Accordion title="Checked on every action" icon="shield-halved">
    A commenter can't generate or send even if they reach the right screen — the server denies the action. Members get exactly their role's permissions, nothing extra.
  </Accordion>

  <Accordion title="Owner and admins get manager access" icon="crown">
    The account owner (and org admins) automatically have manager access to every brand in the account, without an explicit invite.
  </Accordion>

  <Accordion title="All-brands Manager can run the account" icon="key">
    A Manager on **all brands** can manage sending domains, People, invites, seats, and API keys, whether they hold a paid seat or are a free collaborator. A Manager on **one brand** cannot. Plan and billing stay with the owner.
  </Accordion>

  <Accordion title="One role per brand" icon="user-gear">
    Access is granted per brand. Account-wide invites apply the same role across all of your brands at once.
  </Accordion>
</AccordionGroup>

***

## Related

<CardGroup>
  <Card title="Workspaces, seats & real-time" icon="users" href="/collaboration/overview">
    Hub for workspaces, seats, and live editing.
  </Card>

  <Card title="Workspaces" icon="building" href="/collaboration/workspaces">
    Switch team workspace and shared credits.
  </Card>

  <Card title="Real-time collaboration" icon="bolt" href="/collaboration/realtime">
    Presence and live canvas on a shared brand.
  </Card>

  <Card title="Visual canvas" icon="diagram-project" href="/creating-emails/visual-canvas">
    The shared canvas where your team plans and builds emails together.
  </Card>

  <Card title="Agencies & client brands" icon="briefcase" href="/collaboration/agencies">
    Run client work, and bring clients in to review without a seat.
  </Card>
</CardGroup>


# Workspaces
Source: https://docs.migma.ai/collaboration/workspaces

A workspace is the billing and membership boundary for your Migma account. Your brands (projects) live inside a workspace.

A **workspace** is the billing and membership boundary for your Migma account. Your **brands** (projects) live inside a workspace. Teammates, seats, and sending quotas all follow the **active workspace** you have selected.

***

## Personal vs team workspace

| | Personal workspace | Team workspace |
| - | - | - |
| Who owns it | You | Usually your company or agency account |
| Your role | Owner | Owner, admin, or member |
| Plan and seats | Your subscription | The owner pays for the plan and your seat |
| AI generation | Your plan's credits | Premium-level limits with a seat, your own plan's credits as a [free collaborator](/collaboration/seats#free-collaborators) |
| Brands | Your brands | Brands the owner shares with you |

Most solo users only see **Personal workspace**. After you accept a team invite, that workspace appears in the switcher too.

***

## Switch workspace

<Steps>
  <Step title="Open your profile menu">
    Click your avatar at the bottom of the sidebar.
  </Step>

  <Step title="Open the workspace row">
    The top row shows the active workspace name, your role, and plan.
  </Step>

  <Step title="Pick a workspace">
    Choose **Personal workspace** or a team workspace. A checkmark marks the active one.
  </Step>
</Steps>

The sidebar plan meter updates to match the active workspace: your effective plan and your monthly **credits remaining**.

Only the **owner** sees **Upgrade** or **Manage** for billing. A **manager on all brands** can manage sending domains and People. They cannot change the plan.

<Tip>
  Joining a paid team workspace does not require a paid personal plan. A seat from the owner grants you Premium-level generation, and sending runs on the workspace owner's quota.
</Tip>

***

## Credits and usage

AI generation is metered **per person**, based on what the workspace grants you:

* Holding a **paid seat** gives you Premium-level generation limits on your own account.
* A **free collaborator** generates on their own plan's credits. See [Free collaborators](/collaboration/seats#free-collaborators).
* Switching workspace refetches your plan and usage in the sidebar.

Campaign **sending** quotas belong to the workspace owner, since campaigns send from the owner's domain and plan. See [Billing and plans](/get-started/billing-and-plans) for plan tiers.

***

## Brands inside a workspace

**Brand** in the UI maps to a **project** in the API. Invites and roles are per brand; workspace membership controls which brands you can open.

* **Share** on a brand invites someone to that brand with a role.
* **Settings → People** invites across all brands or selected brands. See [Team access](/collaboration/team-access).

***

## Related

<CardGroup>
  <Card title="Team access" icon="users" href="/collaboration/team-access">
    Roles, Share, and the People settings.
  </Card>

  <Card title="Seats" icon="chair" href="/collaboration/seats">
    Paid seats on the Business plan.
  </Card>

  <Card title="Real-time collaboration" icon="satellite-dish" href="/collaboration/realtime">
    Presence, cursors, and canvas sync on a shared brand.
  </Card>

  <Card title="Billing and plans" icon="credit-card" href="/get-started/billing-and-plans">
    Premium, Business, and trial.
  </Card>
</CardGroup>


# Migma vs Brevo
Source: https://docs.migma.ai/comparisons/migma-vs-brevo

Compare Migma and Brevo across AI email creation, preflight, template export, audience and CRM features, campaign sending, automation, and pricing.

Migma and Brevo work best at different points in the email workflow.

**Brevo** is an all-in-one marketing platform for email campaigns, transactional email, contacts, automation, CRM, SMS, and chat.

**Migma** is where teams create, edit, test, and prepare email before it goes to an inbox or another platform.

<CardGroup>
  <Card title="Choose Migma" icon="wand-magic-sparkles">
    Create on-brand email faster, test it before launch, then send from Migma or export to Brevo.
  </Card>

  <Card title="Choose Brevo" icon="envelope">
    Run contacts, automation, SMS, CRM, and campaign sending in Brevo.
  </Card>
</CardGroup>

***

## Quick Comparison

| Need | Migma | Brevo |
| - | - | - |
| AI email generation | Yes | Limited compared with dedicated Migma creation workflows |
| Visual email editing | Yes | Yes |
| Brand import from website | Yes | No direct equivalent |
| Preflight checks | Rendering, links, spelling, compliance basics, deliverability | Platform campaign checks |
| Contact and CRM suite | Audience, tags, segments, topics, suppression, validation | Contacts, CRM, lists, forms, automation |
| Transactional email | Single-send workflows and API sending through supported providers | Transactional email API and SMTP |
| SMS and chat | No | Yes |
| Brevo export | Yes, export email into Brevo | Native destination |
| Direct Brevo sending from Migma campaigns | No, Brevo is an export destination | Native send |

***

## How They Fit Together

Use Migma before Brevo when you want better email creation and QA without moving your audience off Brevo.

Typical workflow:

<Steps>
  <Step title="Create in Migma">
    Generate an email from a prompt, brief, screenshot, Figma file, HTML, or reference.
  </Step>

  <Step title="Review in Migma">
    Edit visually, run Email Preflight, and confirm links, rendering, and deliverability risk.
  </Step>

  <Step title="Export to Brevo">
    Push the finished email to Brevo, then use Brevo for lists, automation, SMS, and final sending.
  </Step>
</Steps>

***

## What Migma Adds

* Faster first drafts from prompts, screenshots, Figma, HTML, websites, and references.
* Brand-aware generation after importing your website.
* Email-safe HTML designed for Outlook, webmail, mobile, and dark mode.
* Preflight before export, so problems are caught before Brevo campaign setup.
* Export workflows for Brevo, Mailchimp, Klaviyo, HubSpot, HTML, PNG, and PDF.
* CLI and MCP support for agent-driven email creation and validation.

***

## What Brevo Adds

* Native campaign sending, transactional email, and SMTP.
* CRM, forms, lists, SMS, WhatsApp, chat, and automation tools.
* Brevo-native reporting and campaign management.
* Contact and list workflows for teams already standardized on Brevo.

***

## Best Fit

| Team | Better fit |
| - | - |
| Team already manages contacts, automation, SMS, and CRM in Brevo | Brevo |
| Team needs better email creation, preview, and preflight before Brevo | Migma + Brevo |
| Team wants one workspace for AI creation, validation, audiences, and sending | Migma |
| Team needs Brevo transactional API or SMS | Brevo |

***

## Related Pages

<CardGroup>
  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Export Migma emails to Brevo and other platforms.
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Test before exporting or sending.
  </Card>

  <Card title="Sending Rules" icon="envelope-circle-check" href="/get-started/what-you-can-send">
    Permission-based sending rules for Migma.
  </Card>

  <Card title="Migma vs Resend" icon="scale-balanced" href="/comparisons/migma-vs-resend">
    Compare Migma with a developer-first delivery API.
  </Card>
</CardGroup>

***

## Sources Checked

Provider docs checked in June 2026:

* [Brevo email marketing](https://www.brevo.com/features/email-marketing/)
* [Brevo developer documentation](https://developers.brevo.com/)
* [Brevo transactional email guide](https://developers.brevo.com/docs/send-a-transactional-email)


# Migma vs Klaviyo
Source: https://docs.migma.ai/comparisons/migma-vs-klaviyo

Compare Migma and Klaviyo for ecommerce email creation, editing, preflight, templates, audiences, flows, campaign sending, export, and pricing.

Migma and Klaviyo are strongest together when ecommerce teams need better email production without replacing Klaviyo.

**Klaviyo** is built around customer data, ecommerce events, segmentation, flows, campaigns, SMS, and revenue reporting.

**Migma** is built around creating email assets quickly, making them editable, and testing them before launch.

<CardGroup>
  <Card title="Choose Migma" icon="wand-magic-sparkles">
    Create, edit, test, and export ecommerce-ready emails faster.
  </Card>

  <Card title="Choose Klaviyo" icon="database">
    Use ecommerce data, flows, segments, SMS, and revenue reporting.
  </Card>
</CardGroup>

***

## Quick Comparison

| Need | Migma | Klaviyo |
| - | - | - |
| AI email generation | Yes | Built-in content tools, not Migma's full creation workflow |
| Brand import from website | Yes | No direct equivalent |
| Visual editing | Yes | Yes |
| Preflight checks | Rendering, links, spelling, compliance basics, deliverability | Platform campaign checks |
| Ecommerce data and flows | Shopify product selection and export workflows | Deep ecommerce events, flows, profiles, and segmentation |
| SMS | No | Yes |
| Klaviyo export | Yes | Native destination |
| Campaign sending | Migma campaigns or connected providers | Native Klaviyo campaigns and flows |
| Developer workflows | SDK, CLI, MCP, API | Klaviyo APIs |

***

## How They Fit Together

Use Migma before Klaviyo when you want to move faster on creative without disrupting Klaviyo flows.

Typical workflow:

* Create product launches, lifecycle emails, winback messages, or sale campaigns in Migma.
* Preserve Liquid-style variables where needed.
* Run Preflight for rendering, links, content, and deliverability risk.
* Export to Klaviyo as a template, then attach it to campaigns or flows.

***

## What Migma Adds

* Prompt, screenshot, Figma, HTML, and reference-based email creation.
* On-brand output after website import.
* Email-safe HTML with Outlook and dark mode handling.
* Preflight before Klaviyo setup.
* Export to Klaviyo plus Mailchimp, HubSpot, Brevo, HTML, PNG, and PDF.
* CLI and MCP workflows for agent-assisted production.

***

## What Klaviyo Adds

* Ecommerce profile, event, and catalog data.
* Automated flows and campaign segmentation.
* SMS and multi-channel customer communication.
* Klaviyo attribution, reporting, and revenue analytics.
* Native campaign and flow sending.

***

## Best Fit

| Team | Better fit |
| - | - |
| Ecommerce team already runs flows and reporting in Klaviyo | Klaviyo |
| Team needs faster email creative before Klaviyo launch | Migma + Klaviyo |
| Team wants AI creation, preflight, export, and optional sending in one workspace | Migma |
| Team needs deep customer event segmentation and SMS | Klaviyo |

***

## Related Pages

<CardGroup>
  <Card title="Klaviyo Integration" icon="database" href="/integrations/klaviyo">
    Export Migma emails into Klaviyo.
  </Card>

  <Card title="Shopify Integration" icon="cart-shopping" href="/integrations/shopify">
    Use Shopify product data in Migma emails.
  </Card>

  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Review supported export paths.
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Test before exporting.
  </Card>
</CardGroup>

***

## Sources Checked

Provider docs checked in June 2026:

* [Klaviyo email marketing](https://www.klaviyo.com/products/email-marketing)
* [Klaviyo API overview](https://developers.klaviyo.com/en/reference/api_overview)
* [Klaviyo getting started guide](https://help.klaviyo.com/hc/en-us/articles/115005054847)


# Migma vs Mailchimp
Source: https://docs.migma.ai/comparisons/migma-vs-mailchimp

Compare Migma and Mailchimp across AI email creation, editing, preflight, audience management, campaign sending, automation, export, and pricing.

Migma and Mailchimp can work together, but they solve different problems.

**Mailchimp** is a marketing platform for audiences, email campaigns, customer journeys, forms, landing pages, and reporting.

**Migma** is the creation and quality layer: generate email, edit it, run preflight, then send from Migma or export to Mailchimp.

<CardGroup>
  <Card title="Choose Migma" icon="wand-magic-sparkles">
    Create and test email before it enters your campaign platform.
  </Card>

  <Card title="Choose Mailchimp" icon="envelope">
    Manage Mailchimp audiences, customer journeys, and campaign reporting.
  </Card>
</CardGroup>

***

## Quick Comparison

| Need | Migma | Mailchimp |
| - | - | - |
| AI email generation | Yes | Built-in assistant features, not Migma's full creation workflow |
| Website brand import | Yes | No direct equivalent |
| Visual editing | Yes | Yes |
| Preflight checks | Rendering, links, spelling, compliance basics, deliverability | Campaign review and platform checks |
| Audience management | Contacts, tags, segments, topics, suppression, validation | Audiences, tags, segments, forms, journeys |
| Mailchimp export | Yes | Native destination |
| Direct campaign sending | Yes, through Migma sending or connected delivery providers | Yes, through Mailchimp |
| Developer workflows | SDK, CLI, MCP, API | Marketing API |

***

## How They Fit Together

Use Migma with Mailchimp when Mailchimp stays your audience and sending system, but your team wants faster email production.

Common workflow:

1. Create and edit the email in Migma.
2. Run Email Preflight.
3. Export to Mailchimp as a template or campaign draft.
4. Finish segmentation, approvals, scheduling, and reporting in Mailchimp.

<Info>
  Mailchimp export supports Mailchimp merge tags, so personalization can stay compatible with your Mailchimp audience fields.
</Info>

***

## What Migma Adds

* Prompt-to-email creation from briefs, screenshots, Figma, HTML, and references.
* Brand import from your website.
* Outlook-aware HTML, responsive layouts, dark mode metadata, and editable output.
* Preflight checks before a campaign reaches Mailchimp.
* Export to Mailchimp plus HTML, PNG, PDF, Klaviyo, HubSpot, and Brevo.
* Agent workflows through CLI and MCP.

***

## What Mailchimp Adds

* Mailchimp audience management and signup forms.
* Customer journeys and campaign scheduling.
* Mailchimp reporting and attribution.
* Native Mailchimp template storage and campaign launch.
* Mailchimp Marketing API for teams already building there.

***

## Best Fit

| Team | Better fit |
| - | - |
| Team lives in Mailchimp and needs better email creation | Migma + Mailchimp |
| Team wants one AI workspace for creation, validation, audiences, and sending | Migma |
| Team needs Mailchimp customer journeys, forms, and reporting | Mailchimp |
| Team needs production HTML that can move between ESPs | Migma |

***

## Related Pages

<CardGroup>
  <Card title="Mailchimp Integration" icon="envelope" href="/integrations/mailchimp">
    Export directly from Migma to Mailchimp.
  </Card>

  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    See supported export formats and platforms.
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Run checks before exporting.
  </Card>

  <Card title="Migma vs Brevo" icon="scale-balanced" href="/comparisons/migma-vs-brevo">
    Compare Migma with another marketing platform.
  </Card>
</CardGroup>

***

## Sources Checked

Provider docs checked in June 2026:

* [Mailchimp email marketing](https://mailchimp.com/features/email/)
* [Mailchimp marketing automation](https://mailchimp.com/features/marketing-automation/)
* [Mailchimp Marketing API fundamentals](https://mailchimp.com/developer/marketing/docs/fundamentals/)


# Migma vs Resend
Source: https://docs.migma.ai/comparisons/migma-vs-resend

Compare Migma and Resend for visual email creation, React and HTML workflows, preflight, transactional sending, marketing campaigns, APIs, and pricing.

## Overview

Migma and Resend are both developer-focused email platforms, but they solve fundamentally different problems. **Resend** is a transactional email delivery API — you write the HTML, they send it. **Migma** is an AI-powered email platform that generates, validates, previews, and sends emails — all from a single API.

<CardGroup>
  <Card title="Migma" icon="wand-magic-sparkles">
    AI email generation + delivery + validation + previews in one API. Import your brand, describe what you want, get production-ready email HTML — then send it.
  </Card>

  <Card title="Resend" icon="paper-plane">
    Email delivery API. You provide the HTML, they handle DKIM/SPF and deliver it to inboxes.
  </Card>
</CardGroup>

***

## Quick Comparison

| Feature | Migma | Resend |
| - | - | - |
| **AI email generation** | Prompt-to-email with brand awareness | No |
| **Email sending** | Built-in + SES, SendGrid, Mailgun, Resend | Built-in only |
| **Contact management** | Full CRM (tags, segments, topics, bulk import) | Basic (contacts + segments) |
| **Email validation** | Compatibility, links, spelling, deliverability | No |
| **Device previews** | 20+ real devices | No |
| **Export formats** | HTML, PDF, PNG, Klaviyo, Mailchimp, HubSpot | HTML only |
| **Brand import** | Auto-import from any website (colors, fonts, logos) | No |
| **Webhooks** | HMAC-signed with delivery history | HMAC-signed with retry |
| **Broadcast/campaigns** | Send to segments, tags, topics | Send to segments (Broadcasts) |
| **Node.js SDK** | Yes (`migma`) | Yes (`resend`) |
| **SDK languages** | Node.js/TypeScript | Node.js, Python, Go, Ruby, PHP, Java, Rust, .NET, Elixir |
| **CLI** | Yes (`@migma/cli`) | No |
| **MCP server** | Yes (Claude, Cursor, etc.) | No |
| **Managed domains** | Instant (no DNS setup) | No |
| **Inbound email** | No | Yes |
| **SMTP relay** | No | Yes |
| **Multi-region** | Single region | 4 regions |

***

## Pricing

### Migma Plans

Migma offers two paid plans (both include a **7-day free trial** when you first subscribe):

| Plan | Price | AI Emails/Day | Sending/Month | Projects |
| - | - | - | - | - |
| **Premium** | \$99.99/mo | 100 | 200,000 | Unlimited |
| **Business** | \$299/mo | Unlimited | 3,000,000 | Unlimited |

<Info>
  Annual billing saves up to 23%: Premium at $950/year, Business at $2,748/year.
</Info>

### Resend Plans

| Plan | Price | Emails/Month | Overage | Domains | Webhooks |
| - | - | - | - | - | - |
| **Free** | \$0 | 3,000 (100/day) | N/A | 1 | 1 endpoint |
| **Pro** | \$20/mo | 50,000 | \$0.90/1,000 | 10 | 10 endpoints |
| **Scale** | \$90/mo | 100,000 | \$0.90/1,000 | 1,000 | 10 endpoints |
| **Enterprise** | Custom | Custom | Custom | Flexible | Flexible |

### What You Get for the Price

The pricing models reflect the different value propositions:

**Resend at \$20/mo** gives you:

* Email delivery API (you provide the HTML)
* 50,000 sends
* Basic contact management

**Migma at \$99.99/mo** gives you everything Resend offers, plus:

* AI-powered email generation (100 emails/day)
* Automatic brand import from any website
* Email validation (compatibility, links, spelling, deliverability)
* Device previews on 20+ real devices
* Export to Klaviyo, Mailchimp, HubSpot, PNG, PDF
* Full audience management (tags, segments, topics, preference center)
* AI image & GIF generation
* CLI and MCP server for AI-assisted workflows

<Tip>
  Migma's Premium plan includes AI email generation, validation, previews, and multi-platform export — capabilities you'd need to piece together from multiple separate tools with Resend.
</Tip>

***

## API Design & Code Examples

Both platforms use REST APIs with Bearer token auth and return JSON. Here's how common workflows compare.

### Authentication

<Tabs>
  <Tab title="Migma">
    ```typescript theme={null}
    import Migma from 'migma';

    const migma = new Migma('sk_live_...');
    ```

    API keys support granular permissions: `audience:read`, `email:send`, `domain:write`, etc.
  </Tab>

  <Tab title="Resend">
    ```typescript theme={null}
    import { Resend } from 'resend';

    const resend = new Resend('re_...');
    ```

    API keys are scoped to Full Access or Sending Access only.
  </Tab>
</Tabs>

### Sending an Email

<Tabs>
  <Tab title="Migma">
    ```typescript theme={null}
    import Migma from 'migma';

    const migma = new Migma('sk_live_...');

    // Option 1: Send a selected Migma email slot
    await migma.sending.send({
      recipientType: 'email',
      recipientEmail: 'sarah@example.com',
      from: 'hello@yourbrand.com',
      fromName: 'Your Brand',
      subject: 'Welcome aboard!',
      emailId: 'email_123',
    });

    // Option 2: Generate with AI, then send
    const email = await migma.emails.generateAndWait({
      projectId: 'proj_123',
      prompt: 'Create a welcome email for new subscribers',
    });

    await migma.sending.send({
      recipientType: 'email',
      recipientEmail: 'sarah@example.com',
      from: 'hello@yourbrand.com',
      fromName: 'Your Brand',
      subject: email.data.result.subject,
      conversationId: email.data.conversationId,
    });
    ```
  </Tab>

  <Tab title="Resend">
    ```typescript theme={null}
    import { Resend } from 'resend';

    const resend = new Resend('re_...');

    // You must provide the HTML yourself
    const { data, error } = await resend.emails.send({
      from: 'Your Brand <hello@yourbrand.com>',
      to: ['sarah@example.com'],
      subject: 'Welcome aboard!',
      html: '<html>Your HTML here</html>',
    });
    ```
  </Tab>
</Tabs>

`★ Insight ─────────────────────────────────────`
**Key difference**: With Resend, you bring your own HTML. With Migma, you can pick a generated email by `emailId` or describe what you want and let AI generate it — on-brand, dark-mode optimized, and cross-client compatible.
`─────────────────────────────────────────────────`

### Sending to a Segment

<Tabs>
  <Tab title="Migma">
    ```typescript theme={null}
    // Send to an entire audience segment
    const { data } = await migma.sending.send({
      recipientType: 'segment',
      recipientId: 'seg_456',
      from: 'hello@yourbrand.com',
      fromName: 'Your Brand',
      subject: 'Summer Sale - 30% Off',
      emailId: 'email_123',
      topicId: 'topic_promotions', // preference center
    });

    // Track batch delivery
    const status = await migma.sending.getBatchStatus(data.batchId);
    console.log(`Sent: ${status.data.successCount}/${status.data.totalRecipients}`);
    ```
  </Tab>

  <Tab title="Resend">
    ```typescript theme={null}
    // Create a broadcast for the segment
    const { data, error } = await resend.broadcasts.create({
      segmentId: 'seg_456',
      from: 'Your Brand <hello@yourbrand.com>',
      subject: 'Summer Sale - 30% Off',
      html: '<html>Your HTML here</html>',
      send: true, // send immediately
    });
    ```
  </Tab>
</Tabs>

### Contact Management

<Tabs>
  <Tab title="Migma">
    ```typescript theme={null}
    // Create a contact with tags
    const { data } = await migma.contacts.create({
      email: 'steve@example.com',
      firstName: 'Steve',
      lastName: 'Smith',
      country: 'US',
      language: 'en',
      tags: ['premium', 'early-adopter'],
      customFields: { plan: 'enterprise', company: 'Acme' },
      projectId: 'proj_123',
    });

    // Bulk import (auto-async for >5000 contacts)
    const { data: bulk } = await migma.contacts.bulkImport({
      projectId: 'proj_123',
      subscribers: contacts, // up to 100,000+
    });

    // List with cursor-based pagination
    const { data: page } = await migma.contacts.list({
      projectId: 'proj_123',
      limit: 50,
      status: 'subscribed',
      tags: ['premium'],
    });
    ```
  </Tab>

  <Tab title="Resend">
    ```typescript theme={null}
    // Create a contact
    const { data, error } = await resend.contacts.create({
      email: 'steve@example.com',
      firstName: 'Steve',
      lastName: 'Smith',
      unsubscribed: false,
    });

    // List contacts (no filtering by tags or custom fields)
    const { data: contacts } = await resend.contacts.list({
      audienceId: 'aud_123',
    });
    ```
  </Tab>
</Tabs>

### Error Handling

Both SDKs use the same `{ data, error }` pattern — no try/catch needed:

<Tabs>
  <Tab title="Migma">
    ```typescript theme={null}
    const { data, error } = await migma.contacts.create({
      email: 'sarah@example.com',
      projectId: 'proj_123',
    });

    if (error) {
      console.error(error.code);       // 'validation_error'
      console.error(error.statusCode); // 400
      console.error(error.message);    // 'Email is required'
      return;
    }

    console.log(data.id); // TypeScript narrows — data is guaranteed non-null
    ```
  </Tab>

  <Tab title="Resend">
    ```typescript theme={null}
    const { data, error } = await resend.emails.send({
      from: 'hello@example.com',
      to: ['sarah@example.com'],
      subject: 'Hello',
      html: '<p>Hi</p>',
    });

    if (error) {
      console.error(error.name);    // 'validation_error'
      console.error(error.message); // 'Missing required field'
      return;
    }

    console.log(data.id);
    ```
  </Tab>
</Tabs>

***

## What Migma Does That Resend Doesn't

### AI Email Generation

Describe what you want, get production-ready HTML:

```typescript theme={null}
const email = await migma.emails.generateAndWait({
  projectId: 'proj_123',
  prompt: 'Create a product launch email for our new wireless headphones. ' +
          'Highlight noise cancellation, 40-hour battery, and the $99 intro price.',
  languages: ['en', 'es'], // generate in multiple languages
});

// Returns complete, on-brand HTML — ready to send
console.log(email.data.result.subject); // "Introducing QuietMax Pro — $99 Launch Offer"
console.log(email.data.result.html);    // full responsive HTML with dark mode support
```

With Resend, you'd need to design and code the email yourself (or use a separate design tool), then pass the finished HTML to the API.

### Brand Import

Import your brand identity from any website in one API call:

```typescript theme={null}
const brand = await migma.projects.importAndWait({
  urls: ['https://yourbrand.com']
});

// Automatically extracts: colors, typography, logos, tone of voice
// Every email generated after this matches your brand
```

Resend has no equivalent — you manually configure each email's styling.

### Email Validation

Test emails before sending — no third-party tools needed:

```typescript theme={null}
// Run all validation checks at once
const { data } = await migma.validation.all({
  conversationId: 'conv_789',
});

// Or run individually:
await migma.validation.compatibility({ conversationId: 'conv_789' }); // 20+ email clients
await migma.validation.links({ conversationId: 'conv_789' });         // broken link detection
await migma.validation.spelling({ conversationId: 'conv_789' });      // grammar & spelling
await migma.validation.deliverability({ conversationId: 'conv_789' }); // spam score analysis
```

Resend doesn't offer validation. You'd need separate tools like Litmus or Email on Acid.

### Device Previews

See how your email renders on 20+ real devices:

```typescript theme={null}
const preview = await migma.previews.createAndWait({
  conversationId: 'conv_789',
});

// Get screenshots for specific devices
const iphone = await migma.previews.getDevice(preview.data.previewId, 'iphone-15-pro');
const gmail = await migma.previews.getDevice(preview.data.previewId, 'gmail-dark');
```

### Multi-Platform Export

Export to any email platform — not just HTML:

```typescript theme={null}
// Export to multiple formats from a single generation
await migma.export.html('conv_789');       // raw HTML
await migma.export.png('conv_789');        // PNG image
await migma.export.pdf('conv_789');        // PDF attachment
await migma.export.klaviyo('conv_789');    // Klaviyo-ready format
await migma.export.mailchimp('conv_789');  // Mailchimp template
await migma.export.hubspot({ conversationId: 'conv_789' }); // HubSpot
```

### CLI & AI Tool Integration

```bash theme={null}
# Generate from your terminal
migma generate --project proj_123 --prompt "Welcome email for new users"

# Send a test
migma send --to test@example.com --conversation conv_789

# Validate before sending
migma validate --conversation conv_789
```

Migma also ships [MCP](/mcp-server) so you can use it directly from Claude Desktop, Cursor, Windsurf, and other AI tools.

***

## What Resend Does That Migma Doesn't

### Wider SDK Support

Resend offers official SDKs in 9 languages:

<CardGroup>
  <Card title="Node.js" icon="js" />

  <Card title="Python" icon="python" />

  <Card title="Go" icon="golang" />

  <Card title="Ruby" icon="gem" />

  <Card title="PHP" icon="php" />

  <Card title="Java" icon="java" />

  <Card title="Rust" icon="rust" />

  <Card title=".NET" icon="microsoft" />

  <Card title="Elixir" icon="droplet" />
</CardGroup>

Migma currently offers a Node.js/TypeScript SDK. If you work in Python, Go, or another language, you can use Migma's REST API directly — or use Resend for the sending layer and Migma for generation.

### SMTP Relay

Resend supports SMTP as an alternative to their REST API:

```yaml theme={null}
Host: smtp.resend.com
Port: 465 (TLS) or 587 (STARTTLS)
Username: resend
Password: re_your_api_key
```

Migma is REST API only — there's no SMTP interface.

### Inbound Email

Resend can receive emails on your domain, not just send them. This is useful for building support inboxes or email-based workflows.

### Multi-Region Sending

Resend supports 4 sending regions (`us-east-1`, `eu-west-1`, `sa-east-1`, `ap-northeast-1`). Migma currently operates from a single region.

***

## Using Them Together

Migma and Resend aren't mutually exclusive. Migma supports Resend as a sending provider — use Migma for generation and validation, send through Resend:

```typescript theme={null}
import Migma from 'migma';

const migma = new Migma('sk_live_...');

// Generate the email with Migma's AI
const email = await migma.emails.generateAndWait({
  projectId: 'proj_123',
  prompt: 'Create a welcome email for new subscribers',
});

// Send through Resend (or SES, SendGrid, Mailgun)
await migma.sending.send({
  recipientType: 'email',
  recipientEmail: 'sarah@example.com',
  from: 'hello@yourbrand.com',
  fromName: 'Your Brand',
  subject: email.data.result.subject,
  conversationId: email.data.conversationId,
  providerType: 'resend', // use your connected Resend account
});
```

<Info>
  Connect your Resend account in **Settings > Integrations > Email Service Providers** to enable this workflow. See the [ESP integration guide](/integrations/email-service-providers) for details.
</Info>

***

## When to Choose Migma

<Check>You want AI to generate on-brand emails from a text prompt</Check>
<Check>You need email validation, previews, and deliverability testing built in</Check>
<Check>You want to export to Klaviyo, Mailchimp, HubSpot, or PNG</Check>
<Check>You want a CLI and MCP server for AI-assisted workflows</Check>
<Check>You need full audience management (tags, segments, topics, preference center)</Check>
<Check>You want instant sending domains with no DNS setup</Check>

## When to Choose Resend

<Check>You only need transactional email delivery (you already have the HTML)</Check>
<Check>You need SDKs in Python, Go, Ruby, PHP, Java, Rust, or .NET</Check>
<Check>You need SMTP relay support</Check>
<Check>You need inbound email (receiving emails)</Check>
<Check>You need multi-region sending for data residency compliance</Check>

***

## Summary

| | Migma | Resend |
| - | - | - |
| **Best for** | Teams that want AI to handle email creation, testing, and delivery end-to-end | Developers who build their own email templates and need reliable delivery |
| **Starting price** | \$99.99/mo (Premium) | \$20/mo (Pro) |
| **Trial / free tier** | 7-day trial on Premium or Business | 3,000 emails/month, 100/day |
| **Core strength** | AI generation + validation + previews + multi-platform export | Fast, reliable email delivery with great DX |
| **API endpoints** | 51+ | \~25 |
| **SDK resources** | 14 resource classes | \~8 resource classes |

***

## Get Started

<CardGroup>
  <Card title="Try Migma" icon="rocket" href="https://migma.ai">
    Start with a 7-day trial on Premium or Business
  </Card>

  <Card title="Quickstart Guide" icon="bolt" href="/quickstart">
    Import your brand and send your first email in 5 minutes
  </Card>

  <Card title="SDK Reference" icon="npm" href="/sdk">
    Full Node.js SDK documentation with all 14 resources
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Complete endpoint documentation
  </Card>
</CardGroup>


# Migma vs SendGrid
Source: https://docs.migma.ai/comparisons/migma-vs-sendgrid

Compare Migma and Twilio SendGrid for email creation, editing, preflight, transactional delivery, marketing campaigns, API workflows, and pricing.

Migma and SendGrid can be used together, but they are not the same type of product.

**SendGrid** is a mature email delivery platform with Email API, SMTP, templates, marketing campaigns, contacts, and deliverability tooling.

**Migma** is an AI-native workspace for creating, editing, testing, sending, and exporting email.

<CardGroup>
  <Card title="Choose Migma" icon="wand-magic-sparkles">
    Generate and preflight production email before it is sent or exported.
  </Card>

  <Card title="Choose SendGrid" icon="paper-plane">
    Use a mature delivery API, SMTP relay, and SendGrid-native sending tools.
  </Card>
</CardGroup>

***

## Quick Comparison

| Need | Migma | SendGrid |
| - | - | - |
| AI email generation | Yes | No dedicated Migma-style generation workflow |
| Brand import from website | Yes | No direct equivalent |
| Visual editing | Yes | Template editors and design tools |
| Preflight checks | Rendering, links, spelling, compliance basics, deliverability | SendGrid deliverability and campaign tooling |
| Transactional sending | Single-send and API workflows through Migma or providers | Email API and SMTP |
| Marketing campaigns | Migma campaigns, audiences, scheduling, metrics | Marketing Campaigns |
| SendGrid delivery from Migma | Yes, connect SendGrid as a sending provider | Native delivery platform |
| SMTP | No | Yes |
| Export to other ESPs | HTML, PNG, PDF, Mailchimp, Klaviyo, HubSpot, Brevo | Not the main workflow |

***

## How They Fit Together

Use Migma with SendGrid when SendGrid remains your delivery infrastructure, but Migma handles email production and QA.

Common workflow:

1. Create or import the email in Migma.
2. Edit visually and run Email Preflight.
3. Send through a connected SendGrid provider or export HTML for your existing SendGrid workflow.
4. Track campaign results in the system that owns the send.

***

## What Migma Adds

* AI generation from prompts, screenshots, Figma, HTML, websites, and references.
* Editable, email-safe HTML output.
* Preflight checks before delivery.
* Audience validation, suppression, skipped-recipient review, and campaign workflows.
* Export to multiple ESPs and formats.
* SDK, CLI, and MCP workflows for agents and developers.

***

## What SendGrid Adds

* Email API and SMTP relay.
* Mature sender authentication and delivery infrastructure.
* SendGrid Marketing Campaigns, contacts, templates, and reporting.
* Existing SendGrid workflows for engineering teams and high-volume senders.

***

## Best Fit

| Team | Better fit |
| - | - |
| Developers need API or SMTP delivery for existing templates | SendGrid |
| Marketing needs faster on-brand email creation and QA | Migma |
| Team wants Migma creative workflow but SendGrid delivery | Migma + SendGrid |
| Team uses SendGrid Marketing Campaigns as system of record | SendGrid |
| Team wants AI creation, preflight, audience validation, and export in one workspace | Migma |

***

## Related Pages

<CardGroup>
  <Card title="Email Service Providers" icon="server" href="/integrations/email-service-providers">
    Connect SendGrid and other sending providers.
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Test emails before sending.
  </Card>

  <Card title="Sending Emails" icon="paper-plane" href="/audience/sending-emails">
    Send from Migma through supported providers.
  </Card>

  <Card title="Migma vs Resend" icon="scale-balanced" href="/comparisons/migma-vs-resend">
    Compare Migma with another developer-first delivery platform.
  </Card>
</CardGroup>

***

## Sources Checked

Provider docs checked in June 2026:

* [Twilio SendGrid](https://www.twilio.com/en-us/sendgrid)
* [SendGrid Email API guide](https://www.twilio.com/docs/sendgrid/for-developers/sending-email/api-getting-started)
* [SendGrid Marketing Campaigns guide](https://www.twilio.com/docs/sendgrid/ui/sending-email/how-to-send-email-with-marketing-campaigns)


# CAN-SPAM Checklist
Source: https://docs.migma.ai/compliance/can-spam-checklist

Use this CAN-SPAM checklist to identify commercial email, set accurate sender details and subjects, include an address, and honor opt-outs promptly.

The **CAN-SPAM Act** sets rules for commercial email in the United States. You are responsible for your sending practices. Migma provides tools that help you meet common requirements, but this page is guidance—not legal advice.

<Info>
  For permission-based sending rules (no cold email), read [Permission-based sending](/get-started/what-you-can-send) first.
</Info>

***

## Before you send marketing email

<Steps>
  <Step title="Accurate header information">
    **From**, **To**, and **Reply-To** must be accurate and identify you as the sender.

    **In Migma:** Configure sender name, from address, and reply-to in project or domain settings. Use a monitored reply address—not `no-reply`—when possible.
  </Step>

  <Step title="Truthful subject lines">
    Subject lines must reflect the content of the message. Avoid deceptive patterns such as fake replies or urgent security alerts for promotions.

    **In Migma:** Email Preflight flags risky subject and content patterns. Use **Fix with AI** to revise copy before sending.
  </Step>

  <Step title="Physical mailing address">
    Commercial email must include a valid physical postal address.

    **In Migma:** Set your business address in compliance or brand settings so footers and preference pages can include it automatically.
  </Step>

  <Step title="Clear unsubscribe">
    Recipients must be able to opt out easily, without login or extra steps.

    **In Migma:** Marketing emails include unsubscribe handling through your sending setup and [Preference center](/audience/preference-center). Honor opt-outs promptly; suppressed contacts should not receive marketing sends.
  </Step>

  <Step title="Honor opt-outs quickly">
    CAN-SPAM requires processing opt-out requests within 10 business days. Faster is better for trust and deliverability.

    **In Migma:** Unsubscribe and suppression flows are designed for immediate effect on marketing sends. See [Suppression list](/sending-domains/suppression-list).
  </Step>

  <Step title="Monitor senders on your behalf">
    If agencies or teammates send for you, you remain responsible for their compliance.

    **In Migma:** Use team permissions and audit sending activity. See [Security & Compliance](/security/compliance) for access controls and logging.
  </Step>
</Steps>

***

## Quick checklist

<Check>Sender identity is accurate and matches your brand</Check>
<Check>Subject line matches email content</Check>
<Check>Physical address appears in the footer (where required)</Check>
<Check>Unsubscribe or preference link is visible and works</Check>
<Check>Contacts opted in to marketing (not cold lists)</Check>
<Check>Preflight run for compliance and deliverability warnings</Check>
<Check>Sending domain authenticated (SPF, DKIM, DMARC where applicable)</Check>

***

## Common mistakes

<AccordionGroup>
  <Accordion title="Promotional email marked as transactional" icon="triangle-exclamation">
    Using transactional sending flags for marketing content violates recipient expectations and CAN-SPAM intent. Send promotions only to contacts with marketing consent.
  </Accordion>

  <Accordion title="Missing or hidden unsubscribe" icon="eye-slash">
    Burying unsubscribe links or requiring login increases complaints. Complaints hurt deliverability for your entire domain.
  </Accordion>

  <Accordion title="Imported lists without consent" icon="file-csv">
    Purchased or scraped lists often fail CAN-SPAM and damage reputation. See [CSV Upload](/audience/csv-upload) and [sending rules](/get-started/what-you-can-send).
  </Accordion>
</AccordionGroup>

***

## Related pages

<CardGroup>
  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Automated compliance, spam, and deliverability review.
  </Card>

  <Card title="Security & Compliance" icon="shield-check" href="/security/compliance">
    Full compliance overview including CASL and GDPR.
  </Card>

  <Card title="Acceptable use" icon="file-contract" href="/legal/acceptable-use">
    Platform policy for permission-based email.
  </Card>

  <Card title="Add sending domain" icon="globe" href="/sending-domains/add-domain">
    DNS authentication for trusted sending.
  </Card>
</CardGroup>


# GDPR Newsletter Consent
Source: https://docs.migma.ai/compliance/gdpr-newsletter-consent

Build a GDPR-ready newsletter consent flow with a lawful basis, clear opt-in language, proof of consent, preference controls, and easy withdrawal.

**GDPR** and the **UK GDPR** require a lawful basis before you process personal data for marketing email. For most newsletters, that basis is **consent**—clear, specific, and freely given. This page describes best practices for signup flows. It is not legal advice; consult counsel for your jurisdiction and use case.

***

## Principles for newsletter signups

<CardGroup>
  <Card title="Specific" icon="bullseye">
    Say what people are signing up for—for example product updates and newsletters—not vague "communications."
  </Card>

  <Card title="Affirmative" icon="square-check">
    Use an unchecked box or explicit action. Do not rely on pre-checked marketing consent for EU/UK subscribers.
  </Card>

  <Card title="Informed" icon="circle-info">
    Link to your privacy policy where appropriate. Explain who sends the email and how to unsubscribe.
  </Card>

  <Card title="Documented" icon="file-lines">
    Record when and how consent was collected (form name, timestamp, source) in your systems of record.
  </Card>
</CardGroup>

***

## Good signup patterns

<Check>Standalone checkbox: "Email me product news and newsletters" (unchecked by default)</Check>
<Check>Newsletter form with clear purpose and privacy link</Check>
<Check>Checkout marketing opt-in separated from terms of service acceptance</Check>
<Check>Double opt-in for high-risk or imported funnels (confirm via email before first marketing send)</Check>
<Check>Preference center so subscribers can change topics or unsubscribe anytime</Check>

***

## Patterns to avoid

<Warning>Pre-checked "send me marketing" on EU/UK forms</Warning>
<Warning>Bundling newsletter consent into account creation with no separate choice</Warning>
<Warning>Adding event attendees to marketing lists without explicit newsletter consent</Warning>
<Warning>Importing CRM or sales contacts who never opted in to marketing email</Warning>
<Warning>Assuming legitimate interest covers all promotional email without a documented assessment</Warning>

For list imports, see [Permission-based sending](/get-started/what-you-can-send) and [CSV Upload](/audience/csv-upload).

***

## After signup

<Steps>
  <Step title="Send only what they agreed to">
    If they subscribed to a product newsletter, do not add unrelated promotional streams without new consent.
  </Step>

  <Step title="Make withdrawal easy">
    Every marketing email should link to unsubscribe or [Preference center](/audience/preference-center) options.
  </Step>

  <Step title="Honor data subject requests">
    Support access, correction, and deletion requests per your privacy policy. See [Security & Compliance](/security/compliance) for Migma data rights features.
  </Step>
</Steps>

***

## How Migma helps

<Check>**Preference center** for branded unsubscribe and topic management</Check>
<Check>**Contact status** and suppression so unsubscribed users are skipped on campaigns</Check>
<Check>**Preflight** compliance checks for sender identification and unsubscribe presence</Check>
<Check>**Security & Compliance** documentation for GDPR principles, retention, and DPAs</Check>

Configure double opt-in and consent tracking according to your legal requirements in your signup tools and CRM; Migma is where you design, review, and send email to contacts you already have permission to reach.

***

## Related pages

<CardGroup>
  <Card title="CAN-SPAM checklist" icon="gavel" href="/compliance/can-spam-checklist">
    U.S. commercial email requirements.
  </Card>

  <Card title="Preference center" icon="sliders" href="/audience/preference-center">
    Subscriber-facing preference and unsubscribe experience.
  </Card>

  <Card title="Privacy policy" icon="file-contract" href="/legal/privacy-policy">
    Migma privacy policy (legal).
  </Card>
</CardGroup>


# Generate AI Images for Email
Source: https://docs.migma.ai/content-hub/ai-image-generation

Generate email-ready images in Migma using your logo, products, colors, and brand context, then choose an aspect ratio and add the result to your email.

AI Images live in Creative Studio and the visual editor. Use them when an email needs a product shot, hero image, abstract visual, or supporting graphic that matches your brand.

Migma can use:

* Brand colors
* Logo and visual style
* Product context
* Email placement and size
* Existing images from your brand library

## Common use cases

* Hero image for a launch email
* Product image for a promotion
* Lifestyle image for a newsletter
* Abstract background for a feature announcement
* Replacement image while editing an email

## How to generate an image

<Steps>
  <Step title="Open the visual editor">
    Open an email and click an image or image placeholder.
  </Step>

  <Step title="Open Creative Studio">
    Choose the image action, then open **Generate**.
  </Step>

  <Step title="Describe the image">
    Include subject, setting, style, colors, and where the image will appear.
  </Step>

  <Step title="Review and insert">
    Pick the generated image that fits the email, then insert it.
  </Step>
</Steps>

## Prompt pattern

```text theme={null}
Subject: product photo of our new travel mug
Setting: morning kitchen counter
Style: clean, bright, premium
Brand: use our green accent color
Composition: wide hero image with space for headline
```

## Best practices

**Name the email context.** A hero image, product tile, and footer illustration need different framing.

**Use concrete subjects.** Product, person, setting, angle, and mood matter.

**Keep brand guidance short.** Colors, logo use, and style cues are enough.

**Review before sending.** Check image crop, mobile layout, file weight, and dark-mode appearance in preflight.

## Next

<CardGroup>
  <Card title="Visual Email Editor" icon="pen-to-square" href="/email-editor/visual-editor">
    Edit images inside the email.
  </Card>

  <Card title="Email Preflight" icon="shield-check" href="/email-editor/email-preflight">
    Check rendering and quality before sending.
  </Card>
</CardGroup>


# Create Animated GIFs for Email
Source: https://docs.migma.ai/content-hub/animated-gifs

Create animated GIFs in Migma's Visual Editor by describing the motion, adding optional start or end images, and testing the result before sending.

Turn a still image into a looping GIF from the email you are editing.

<Frame>
  <img alt="Animated graphic elements floating gently" />
</Frame>

## Animate an image

<Steps>
  <Step title="Open the email">
    Choose **Edit email**, then select the image you want to animate.
  </Step>

  <Step title="Open the image prompt">
    Choose **Edit with prompt**, then choose **GIF** and **Animate**.
  </Step>

  <Step title="Describe the movement">
    Try “slow zoom toward the product” or “make the shapes float gently.” Add a start or end image when the movement should follow a reference.
  </Step>

  <Step title="Create it">
    Choose **Create**. Migma replaces the selected image with the finished GIF. Use undo if you want the original back.
  </Step>
</Steps>

<Frame>
  <img alt="Migma image prompt showing GIF and Animate controls for a selected email image" />
</Frame>

## Other GIF types

Choose a different GIF type beside **GIF** when you need one:

| Type | Use it for |
| - | - |
| **Slideshow** | Show two or more images in sequence |
| **Before & after** | Toggle between two images |
| **Countdown** | Count down days, hours, minutes, or seconds |
| **Effect** | Add pulse, bounce, zoom, shake, or glow |

## Before you send

* Keep motion short and useful. Large GIFs make emails slower to load.
* Put important meaning in the first frame. Some inboxes may show a still image.
* Add alt text, then send yourself a test.

## Next

<CardGroup>
  <Card title="AI Image Generation" icon="wand-magic-sparkles" href="/content-hub/ai-image-generation">
    Create an image to animate.
  </Card>

  <Card title="Visual Editor" icon="pen-to-square" href="/email-editor/visual-editor">
    Edit the rest of the email.
  </Card>
</CardGroup>


# Email to Blog & Social
Source: https://docs.migma.ai/content-hub/email-to-social

Turn any email into blog articles or social media posts by asking Migma in the chat. Describe what you want, and Migma generates the content based on your email.

## Overview

Turn any email into blog articles or social media posts by asking Migma in the chat. Describe what you want, and Migma generates the content based on your email.

***

## How It Works

From any email conversation in the chat editor, ask Migma to repurpose the content:

**Example prompts:**

* "Turn this email into a blog article"
* "Create a LinkedIn post from this email"
* "Write an Instagram caption based on this email"
* "Generate a Twitter thread from the key points"

Migma uses your email content and brand context to generate platform-appropriate content.

***

## What You Can Generate

<CardGroup>
  <Card title="Blog Articles" icon="newspaper">
    SEO-friendly articles expanded from your email content with headings, intro, and conclusion
  </Card>

  <Card title="Social Posts" icon="share-nodes">
    Platform-optimized posts for LinkedIn, Instagram, Facebook, or Twitter/X
  </Card>
</CardGroup>

***

## Tips

* Be specific about the platform and tone in your prompt
* Ask for hashtags if needed
* Request a specific length or format (e.g., "short LinkedIn post" vs "long-form article")
* The generated content maintains your brand voice

***

## Next Steps

<CardGroup>
  <Card title="AI Image Generation" icon="wand-magic-sparkles" href="/content-hub/ai-image-generation">
    Create images for your social posts
  </Card>

  <Card title="Create Emails" icon="envelope" href="/creating-emails/overview">
    Start with an email to repurpose
  </Card>
</CardGroup>


# Claude Design to Email
Source: https://docs.migma.ai/creating-emails/claude-design

Export an email from Claude's design tool and import it into Migma as editable, responsive email content that you can review, preflight, and publish.

Design an email in Claude's design tool, export it, and bring it straight into Migma as a fully editable email. Claude builds designs as React / JSX components (for example, Claude Artifacts), so Migma takes that export and converts it into a real, email-safe email you can refine, preflight, and send.

The result becomes email-safe HTML for Outlook, Gmail, Apple Mail, and mobile.

## How it works

<Steps>
  <Step title="Design in Claude">
    Build your email in Claude's design tool. Claude exports the design as React / JSX components.
  </Step>

  <Step title="Export as a .zip">
    Download the design as a `.zip` of the React / JSX components.
  </Step>

  <Step title="Open the add-content menu in Migma">
    In the Migma create / chat input, click the **+** (plus) button to open the add-content dropdown.

    <img alt="The plus add-content dropdown in the create input, with Import Claude design in the list" title="The + add-content menu" />
  </Step>

  <Step title="Choose &#x22;Import Claude design&#x22;">
    Select the menu item labeled **Import Claude design**. This is the Claude-design import.
  </Step>

  <Step title="Choose the output, then upload your .zip">
    The **Import a Claude design** dialog opens. Choose **Create editable email** or **Create brand version**, then click **Choose .zip file** and pick the export. Migma reads the zip and converts each email component into an editable email.

    <img alt="The Import a Claude design dialog showing the Create editable email and Create brand version options and the Choose .zip file button" title="Import a Claude design dialog" />
  </Step>
</Steps>

<Tip>
  The Claude-design import is the **Import Claude design** menu item in the add-content dropdown.
</Tip>

***

## Editable or brand version

When you open the dialog, you pick how Migma should treat the design:

<CardGroup>
  <Card title="Create editable email" icon="copy">
    Keep the colors, layout, and styling as designed. A faithful, 1:1 translation of the design you built in Claude. This is the default.
  </Card>

  <Card title="Create brand version" icon="palette">
    Re-theme with your brand colors, voice, and remembered preferences. Migma keeps the layout, structure, and content of the design but maps the palette to your brand.
  </Card>
</CardGroup>

When you choose **Create brand version**, Migma maps the design's colors to your brand by role: page background, accent / CTA fill, body text, and muted text. Where your brand doesn't define a color for a role, the design's original value is kept. Either way, you can keep refining in chat after the import lands.

<Note>
  Both options preserve the layout and structure of your design. The difference is purely the color palette and brand voice: **Create editable email** keeps the design's own colors, **Create brand version** swaps in yours.
</Note>

***

## What happens during import

The import runs in two stages:

<Steps>
  <Step title="Convert React / JSX to editable email">
    Migma reads each email component in your export and translates it into an editable email, applying your editable-or-brand-version choice. If your export contains more than one top-level email component, you get one editable email per component.
  </Step>

  <Step title="Render production HTML">
    Migma renders send-ready HTML. Claude design, Figma, HTML, and screenshot imports use the same email rendering path.
  </Step>
</Steps>

<CardGroup>
  <Card title="Native React / JSX" icon="react">
    Claude exports React / JSX, and that's exactly what this import takes. No screenshot or redraw step in between.
  </Card>

  <Card title="Email-safe HTML" icon="code">
    Migma renders email-safe HTML, so the markup can be reviewed before send.
  </Card>

  <Card title="Renders reliably" icon="envelope">
    Review Outlook, Gmail, Apple Mail, and mobile before send.
  </Card>
</CardGroup>

<Check>Faithful to the design you built in Claude, or re-themed to your brand if you choose Create brand version</Check>
<Check>Stays consistent in dark and light mode. Migma emits explicit color-scheme metadata</Check>
<Check>Lands as a normal Migma email you can keep editing</Check>

***

## After import

Once you upload the zip, Migma takes you into the chat / canvas and the converted email (or emails) stream in. From there each one behaves like any other Migma email:

<Steps>
  <Step title="Refine">
    Adjust copy, layout, colors, and images in the chat or the visual editor.

    <img alt="A converted Claude design open and editable in the Migma editor" title="Converted result in the editor" />
  </Step>

  <Step title="Preflight">
    Run **Email Preflight** to check how it renders across clients and devices before you send.
  </Step>

  <Step title="Export or send">
    Export the email or send it like any other Migma email.
  </Step>
</Steps>

<Tip>
  Don't try to land the final version on import. It's faster to convert first, then refine in chat: "make the header smaller," "swap in my logo," "tighten the spacing between sections."
</Tip>

***

## Dark mode and client rendering

Migma emits explicit color-scheme metadata, so your email stays consistent and renders predictably in both dark and light mode. You get a controlled, intentional result across clients rather than colors flipping unpredictably when a reader has dark mode turned on.

For a full picture of what's supported where, see the client compatibility guide.

***

## Claude Design vs other import methods

| | Claude Design | Figma Import | Image Clone | HTML Import |
| - | - | - | - | - |
| **Input** | React / JSX `.zip` from Claude | Figma file URL | Screenshot or mockup | Existing HTML source |
| **Brand option** | Editable email or brand version | AI conversion | AI + OCR | Direct import |
| **Email-safe** | Yes, rendered through Migma's email engine | Yes | Yes | Yes |
| **Best for** | Emails designed in Claude | Original Figma designs | Competitor emails, mockups | Migrating code |
| **Setup needed** | Export the `.zip` | Figma file access | None | HTML source |

If you designed the email in Claude, the Claude Design import is the most direct path. It takes the React / JSX export natively, and the editable-or-brand-version choice lets you decide up front whether to keep the original look or retheme it to your brand.

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="I can't find the Claude import option" icon="magnifying-glass">
    **Cause:** You're looking in the wrong menu or on a page where the add-content menu is not available.

    **Solution:** Click the **+** button in the create / chat input and choose **Import Claude design**.
  </Accordion>

  <Accordion title="My upload was rejected" icon="file-zipper">
    **Cause:** The import expects a `.zip` of the React / JSX components. If the zip has no JSX modules inside, Migma can't tell it's a Claude design export.

    **Solution:** Export the design from Claude as a `.zip` and upload that file, not the individual files or a screenshot.
  </Accordion>

  <Accordion title="The colors came in wrong" icon="palette">
    **Cause:** The editable-or-brand-version choice controls the palette. **Create editable email** keeps the design's own colors; **Create brand version** swaps in your brand colors.

    **Solution:** Re-run the import with the other option, or just refine the colors in chat after the import lands.
  </Accordion>

  <Accordion title="The result needs adjusting" icon="wand-magic-sparkles">
    **Cause:** The converted email is a starting point, not a final draft.

    **Solution:** Refine it in chat or the visual editor, then run Email Preflight before you send.
  </Accordion>
</AccordionGroup>

***

## What do you want to do next?

<CardGroup>
  <Card icon="pen" href="/email-editor/visual-editor" title="Edit your email">
    Click into any part of the imported email to tweak text, images, or colors.
  </Card>

  <Card icon="clipboard-check" href="/email-editor/email-preflight" title="Preflight before sending">
    Check how your email renders across clients and devices before it goes out.
  </Card>

  <Card icon="envelopes-bulk" href="/email-editor/client-compatibility" title="Client compatibility">
    See how Migma keeps emails rendering reliably across major clients.
  </Card>

  <Card icon="figma" href="/creating-emails/figma-import" title="Figma import">
    Bring a design in straight from your Figma file.
  </Card>

  <Card icon="clone" href="/creating-emails/image-clone" title="Clone from image">
    Recreate any email from a screenshot or mockup.
  </Card>

  <Card icon="file-code" href="/creating-emails/html-import" title="HTML to Email">
    Convert an existing HTML email into a fully compatible Migma email.
  </Card>
</CardGroup>


# Competitor Tracking
Source: https://docs.migma.ai/creating-emails/competitor-tracking

Track competitor newsletters in Migma, analyze their timing and creative patterns, and remix useful layouts into original, on-brand email drafts.

## Overview

Subscribe to any competitor's newsletter and Migma automatically collects their emails, shows sending patterns, and lets you remix their campaigns into your own brand style.

<Frame>
  <img alt="Competitor tracking heatmap" />
</Frame>

***

## How to Watch a Competitor

<Steps>
  <Step title="Open the Competitors tab">
    Go to the **Remix** page and select the **Competitors** tab.
  </Step>

  <Step title="Click Watch Competitor">
    Click **Watch Competitor** and enter the competitor's website URL (e.g. `website.com`).
  </Step>

  <Step title="Click Track">
    Click **Track**. Migma subscribes to their newsletter and begins collecting emails as they arrive.
  </Step>
</Steps>

<Warning>
  Competitor tracking is a paid feature. Free users will be prompted to upgrade.
</Warning>

***

## Browsing Competitor Emails

Collected emails appear in a masonry card grid showing:

* Email screenshot preview
* Company name and logo
* Subject line
* Received date

Click any card to view the full email. Use the search bar and tag filters to narrow results.

<Info>
  **View limits:** Full email views are limited to 10 per day per project. Browsing cards and metadata is unlimited.
</Info>

***

## Company Detail Page

Click a tracked company name to see their detail page with:

* **Brand info** — name, logo, website, industry, country, social links
* **Sending cadence heatmap** — 12-month calendar showing when they send emails. Darker cells = more emails. Click any day to see emails sent on that date.
* **Email archive** — searchable grid of all collected emails from that company

***

## Remix a Competitor Email

<Steps>
  <Step title="Find an email">
    Browse the Competitors tab or a company detail page.
  </Step>

  <Step title="Click Remix">
    Click **Remix** on any email card.
  </Step>

  <Step title="Generate your version">
    You're redirected to the create page with the competitor email as a reference. Write your prompt and Migma generates a new email using the competitor's layout with your brand.
  </Step>
</Steps>

***

## Next Steps

<CardGroup>
  <Card title="Remix Emails" icon="shuffle" href="/creating-emails/remix-emails">
    Browse trending emails and remix them
  </Card>

  <Card title="Create from Prompt" icon="wand-magic-sparkles" href="/creating-emails/prompt-based-creation">
    Generate emails from scratch
  </Card>
</CardGroup>


# Create an Email Series with Migma
Source: https://docs.migma.ai/creating-emails/email-series

Describe a journey in plain language and Migma generates the entire sequence, welcome flows, product launches, onboarding drips, re-engagement campaigns.

Describe a journey in plain language and Migma generates the entire sequence, welcome flows, product launches, onboarding drips, re-engagement campaigns. It plans the narrative arc up front so each email builds on the one before it, and lays the result out on your project's visual canvas as connected slots you can refine email by email.

<Note>
  Every email in a series is a normal Migma email. Each one is fully editable, preflightable, and sendable, the series is just a sequence of them planned together so the story holds across the whole journey.
</Note>

## How it works

Describe the journey you want, including the goal, the audience, and roughly how many emails. Migma plans the arc, then writes and renders every email in the sequence.

<Steps>
  <Step title="Describe the journey">
    Tell Migma the goal in one prompt, for example a 4-email welcome flow or a 3-part launch sequence.
  </Step>

  <Step title="Migma plans the arc">
    It decides the role of each email, the order, and how each one hands off to the next, so the sequence reads as one connected story instead of unrelated sends.
  </Step>

  <Step title="Every email is written">
    Each email is generated and rendered through Migma's email engine, so the whole sequence is email-safe and built for inbox compatibility.
  </Step>

  <Step title="Review on the canvas">
    The finished series lands on your project's visual canvas as connected slots, one card per email, in send order.
  </Step>
</Steps>

```text theme={null}
Create a 4-email welcome series for new subscribers to my coffee subscription.
Email 1: warm welcome and what to expect. Email 2: the story behind our roasts.
Email 3: how to brew. Email 4: a first-order discount.
```

<img alt="A generated email series shown as connected slot cards on the visual canvas" title="A generated series on the canvas" />

***

## Refine the whole sequence in chat

Once the series exists, keep shaping it from chat. You don't edit a static template, you talk to the sequence and it restructures itself.

### Add an email

Insert a new email anywhere in the journey. Give it a role and a few beats to hit, and Migma writes it to match the rest of the sequence.

```text theme={null}
Add a reminder email two days after the welcome
```

### Remove an email

Drop an email you don't need. The remaining emails stay intact and renumber their positions.

```text theme={null}
Remove the brewing-tips email
```

### Reorder emails

Change the order of the journey. Pass the new sequence and Migma rearranges the slots.

```text theme={null}
Move the discount email to the end
```

<Tip>
  If an email refers back to an earlier one ("as we mentioned in the welcome…"), reordering can break that callback. Migma will flag it when it happens so you can fix the reference.
</Tip>

***

## Edit every email at once

The most powerful move is a cross-cutting edit. Ask for one change and Migma applies it to every email in the series at the same time, running each one through the same editing pipeline in parallel. If one email fails, the rest still go through.

```text theme={null}
Shorten every CTA
Soften the tone across all of them
Add the footer logo to every email
```

You can also scope the change to specific emails instead of the whole series when you only want a subset updated.

<img alt="One instruction updating every email in the series at once" title="Editing every email in one step" />

<Check>One instruction, applied to the entire sequence, consistent voice and styling without touching each email by hand.</Check>

***

## Per-email send cadence

For a scheduled journey, each email can carry a send offset, the number of days from the start of the series when it should go out. That's how you space a drip: day 0, day 2, day 5, and so on.

| Email | Role | Send offset |
| - | - | - |
| 1 | Welcome | Day 0 |
| 2 | Brand story | Day 2 |
| 3 | How to brew | Day 5 |
| 4 | First-order discount | Day 7 |

Set or adjust the cadence in chat, and new emails you add slot into the schedule automatically.

```text theme={null}
Send the welcome immediately, the story on day 2, and the discount on day 7
```

<img alt="Series slot cards labeled with their send-offset days" title="Per-email send cadence on the canvas" />

***

## Restore an email to a previous version

Iterating across a whole series sometimes means a change touches an email you wanted to leave alone. You can restore any email to how it looked on an earlier turn, while leaving the rest of the sequence untouched.

```text theme={null}
Only the new emails should be dark — revert the first two to how they were
```

<Note>
  Restore works per email, so you can roll back exactly the slots you mean to and keep every other change you've made.
</Note>

***

## Working with individual emails

Each slot on the canvas is a complete Migma email. Click any card to open it in the editor and work on it on its own, then jump back to the canvas to see it in the context of the full journey.

<AccordionGroup>
  <Accordion title="Edit one email" icon="pen">
    Open a slot and refine its copy, images, layout, or colors just like any single email. Changes stay scoped to that email unless you ask for a series-wide edit.
  </Accordion>

  <Accordion title="Preflight before sending" icon="clipboard-check">
    Run any email in the series through preflight to test it across devices and clients before the journey goes live.
  </Accordion>

  <Accordion title="Duplicate without changing the original" icon="copy">
    Use **Duplicate in new chat** for one slot or **Duplicate series** for the whole sequence. Migma opens the latest canvas version in a new chat so you can try another direction while the original stays intact.
  </Accordion>

  <Accordion title="Send the journey" icon="paper-plane">
    Because each email is a normal Migma email, the whole sequence is ready to schedule and send once you're happy with it.
  </Accordion>
</AccordionGroup>

***

## What do you want to do next?

<CardGroup>
  <Card icon="wand-magic-sparkles" href="/creating-emails/prompt-based-creation" title="Prompt-based creation">
    Learn how a single prompt turns into a finished, on-brand email.
  </Card>

  <Card icon="user" href="/creating-emails/persona" title="Write for a persona">
    Aim the whole sequence at a specific audience so the journey lands.
  </Card>

  <Card icon="clipboard-check" href="/email-editor/email-preflight" title="Preflight before sending">
    Preflight each email before the journey goes out.
  </Card>

  <Card icon="diagram-project" href="/creating-emails/visual-canvas" title="The visual canvas">
    See the whole sequence as connected nodes you can arrange and edit.
  </Card>
</CardGroup>


# Designing in Figma for Email
Source: https://docs.migma.ai/creating-emails/figma-design-guide

Email is not a poster. It is a stack of rows that has to render the same way in Gmail, Outlook, Apple Mail, and on every phone.

## Overview

Email is not a poster. It is a stack of rows that has to render the same way in Gmail, Outlook, Apple Mail, and on every phone. Migma reads the structure of your Figma frame, plus a picture of it, and rebuilds it as real email. The closer your file is to how email actually works, the better the result.

<Note>
  **The one rule: design like an email, not a free canvas.** Stack content from top to bottom, in clean named layers, with real text and real images. Every guideline below follows from that.
</Note>

<img alt="A comparison between a free canvas Figma design and an email-ready Auto Layout frame" title="Design like email, not canvas" />

<CardGroup>
  <Card title="Build with Auto Layout" icon="table-columns">
    Stack sections vertically, group columns horizontally, never free position.
  </Card>

  <Card title="Keep text and buttons real" icon="font">
    Never bake words or buttons into a picture.
  </Card>

  <Card title="Size your images" icon="image">
    Crop and resize before placing, and keep files light.
  </Card>

  <Card title="Flatten icons and art" icon="bezier-curve">
    Export vectors as PNG instead of leaving live paths.
  </Card>

  <Card title="Name your layers" icon="tag">
    Use real names like logo and hero, not Frame 1.
  </Card>

  <Card title="Animate in Migma" icon="film">
    Figma freezes GIFs, so add motion after import.
  </Card>
</CardGroup>

***

## Build with Auto Layout

Email flows from top to bottom and cannot place one element on top of another. Auto Layout is how you tell Migma the way your sections stack and sit beside each other.

**Do**

* Wrap the whole email in a vertical Auto Layout frame, with each section as a child
* Use horizontal Auto Layout for columns and icon rows
* Keep one main column, around 600px wide

**Don't**

* Use free-floating layers or hand-placed positions
* Overlap elements, because email cannot stack one layer on another, so overlaps flatten or disappear

***

## Keep text and buttons out of images

Headlines, body copy, and buttons must be real text and real buttons, never part of a picture. This is the most common mistake, and it breaks email in ways that look perfectly fine in Figma.

**Do**

* Keep every headline and paragraph as a live text layer
* Build buttons as a real shape with a separate text label
* For a photo behind a headline, put the text above or below it, or over a solid color block

**Don't**

* Bake text into an image, because it cannot be edited, translated, or read by screen readers, and it disappears when a client blocks images
* Bake a button into an image, because it is not a real, clickable link

<Warning>
  Text or buttons placed on top of a photo are the number one reason an imported design looks broken in the inbox. Keep them as their own layers.
</Warning>

***

## Use real images, sized for email

Migma exports each image straight from your frame, so what you place is what you get.

**Do**

* Crop and resize each image to its final size in your image editor before placing it
* Aim for hero images around 1200px wide and content images around 600px
* Keep files light, because oversized images can be dropped during import and leave a gap

**Don't**

* Drop a giant full-resolution photo onto the canvas and crop it with Figma's crop tool, because the heavy original is what gets processed and can fail quietly

***

## Flatten icons and illustrations

Email cannot render vector artwork reliably, so Migma converts your vectors into images. A flattened layer converts far cleaner than a stack of vector paths.

**Do**

* Export logos and custom illustrations as a flattened PNG, then place that image
* For social icons, name the layer after the platform, like Instagram, Facebook, or X, so Migma drops in a crisp icon

**Don't**

* Leave logos, icons, and illustrations as live vector shapes or large groups of paths, because they convert into fuzzy or broken images

***

## Name your layers

Layer names are not only for you. Migma reads them to understand what each block is, and image names become the alt text in the final email.

**Do**

* Name layers for what they are, like `logo`, `hero`, `headline`, `nav`, `footer`, or `product-photo`
* Give every image a real, human name, because it becomes the alt text

**Don't**

* Ship the defaults like `Frame 1`, `Group 27`, `Vector`, or `Rectangle`, because Migma has to guess what they are

***

## Skip animation in Figma

Figma exports a single still frame, so any animation you place in Figma arrives frozen.

**Do**

* Import the static design, then add an animated GIF inside Migma, where animated images are supported

**Don't**

* Place a GIF in Figma expecting it to move, because it arrives as one frozen frame

***

## Quick checklist

| Do | Don't |
| - | - |
| Vertical Auto Layout, one column around 600px | Free-floating or overlapping layers |
| Real text and real buttons | Text or buttons baked into a photo |
| Crop and size images before placing | Huge photos cropped with Figma's crop tool |
| Flatten icons and art to PNG | Live vectors and groups of paths |
| Name layers (`logo`, `hero`, `footer`) | `Frame 1`, `Vector`, `Group 27` |
| Add animation in Migma after import | GIFs placed in Figma |

***

## Import your file

When your file follows these guidelines, importing is the easy part. Connect Figma, copy the link to your frame, and bring it in.

<CardGroup>
  <Card title="Import from Figma" icon="figma" href="/creating-emails/figma-import">
    Connect Figma and convert your frame step by step.
  </Card>

  <Card title="Clone from an image" icon="image" href="/creating-emails/image-clone">
    No Figma file? Turn a screenshot into an email.
  </Card>

  <Card title="Client compatibility" icon="envelopes-bulk" href="/email-editor/client-compatibility">
    How Migma keeps emails rendering everywhere.
  </Card>
</CardGroup>


# Figma to Email
Source: https://docs.migma.ai/creating-emails/figma-import

Import a Figma frame into Migma as editable, responsive email HTML while preserving the design's layout, typography, images, and visual hierarchy.

## Overview

Design in Figma, then import the frame into Migma as editable email HTML with no vendor lock-in.

<Note>
  **Recently improved.** Figma conversion quality is better: layout, spacing, and typography come across more faithfully. The same deterministic engine powers every import, including Figma, image, HTML, and Claude design.
</Note>

<CardGroup>
  <Card title="Cleaner Output" icon="code">
    Cleaner HTML/React, better component detection, improved font handling
  </Card>

  <Card title="Design Structure" icon="ruler">
    Preserves layout, spacing, typography, and visual hierarchy for review
  </Card>

  <Card title="No Lock-In" icon="unlock">
    Export to any ESP or framework
  </Card>
</CardGroup>

***

## Why Figma to Email?

### For Designers

<Check>Design with full creative freedom in Figma</Check>
<Check>No need to learn email HTML constraints</Check>
<Check>Maintain design system consistency</Check>
<Check>Faster than manual hand-off to developers</Check>

### For Developers

<Check>Editable HTML output</Check>
<Check>Email source you can review before export</Check>
<Check>No manual implementation of mockups</Check>
<Check>Email-client compatible out of the box</Check>

### For Teams

<Check>Bridge design-development workflow</Check>
<Check>Reduce back-and-forth iterations</Check>
<Check>Maintain single source of truth (Figma)</Check>
<Check>Scale email production</Check>

***

## How It Works

<Steps>
  <Step title="Design in Figma">
    Create your email design in Figma using frames, components, and auto-layout
  </Step>

  <Step title="Get Figma URL">
    Share your Figma file and copy the URL
  </Step>

  <Step title="Paste in Migma">
    Navigate to Create page and paste Figma URL with special prompt
  </Step>

  <Step title="AI Converts">
    Migma analyzes the design and generates editable email HTML
  </Step>

  <Step title="Review & Export">
    Preview, refine, and export in your preferred format
  </Step>
</Steps>

<img alt="Figma to Email process showing import, conversion, and customization in Migma" title="Figma to Email conversion process" />

***

## Step-by-Step: Import from Figma

### 1. Prepare Your Figma File

**Design guidelines:** Set your file up so it converts cleanly. Build with Auto Layout, use real sized images, flatten icons to images, and name your layers. See the full guide: [Designing in Figma for Email](/creating-emails/figma-design-guide).

### 2. Share Your Figma File

<Steps>
  <Step title="Open Sharing Settings">
    Click **Share** button in top-right of Figma
  </Step>

  <Step title="Set Permissions">
    Choose **"Anyone with the link can view"**

    <Warning>
      **Important:** File must be publicly accessible or shared with Migma
    </Warning>
  </Step>

  <Step title="Copy Link">
    Click **Copy link** to get your Figma file URL
  </Step>
</Steps>

### 3. Import to Migma

<img alt="The Figma to Email import dialog with the Enter Figma URL field" title="Figma to Email import dialog" />

Navigate to **Create** page and use this prompt pattern:

```text theme={null}
Import from Figma: [PASTE YOUR FIGMA URL]

Convert this design to responsive email HTML
```

**Advanced prompt example:**

```text theme={null}
Import from Figma: https://www.figma.com/file/ABC123/Email-Design

Use my brand colors if different from design
Ensure mobile responsive breakpoints
Add alt text to all images
```

### 4. Review Conversion

Migma generates:

* Editable HTML
* Mobile-responsive breakpoints
* Email-client compatible CSS
* Inline styles where needed
* Proper image optimization

<img alt="A converted Figma design open and editable in the Migma editor" title="Converted Figma design in the editor" />

***

## What Migma Converts

### Fully Supported

<CardGroup>
  <Card title="Layout" icon="table-columns">
    Frames, auto-layout, grids, columns
  </Card>

  <Card title="Typography" icon="text">
    Text styles, fonts, sizes, colors, alignment
  </Card>

  <Card title="Colors" icon="droplet">
    Fills, gradients (simplified for email), borders
  </Card>

  <Card title="Images" icon="image">
    Image fills, exports, backgrounds
  </Card>

  <Card title="Shapes" icon="shapes">
    Rectangles, rounded corners, borders
  </Card>

  <Card title="Spacing" icon="arrows-left-right">
    Padding, margins, auto-layout gaps
  </Card>
</CardGroup>

### ⚠️ Converted with Adaptations

<AccordionGroup>
  <Accordion title="Complex Shapes" icon="draw-polygon">
    **What happens:** Complex vectors simplified to rectangles or images

    **Best practice:** Use simple shapes or export as images
  </Accordion>

  <Accordion title="Advanced Effects" icon="wand-sparkles">
    **What happens:** Shadows, blurs converted to email-safe alternatives

    **Best practice:** Keep effects minimal for email compatibility
  </Accordion>

  <Accordion title="Animations" icon="film">
    **What happens:** Converted to static state

    **Best practice:** Use static designs or simple GIFs
  </Accordion>

  <Accordion title="Custom Fonts" icon="font-case">
    **What happens:** Fallbacks provided for unsupported fonts

    **Best practice:** Use Google Fonts or web-safe fonts
  </Accordion>
</AccordionGroup>

***

## Export Formats

Choose your preferred output format:

<Tabs>
  <Tab title="HTML">
    **Standard HTML with inline CSS**

    **Best for:**

    * Direct ESP upload
    * Maximum compatibility
    * Simple email workflows

    **Includes:**

    * Inline styles
    * Table-based layout (for Outlook)
    * Email-safe CSS
    * Responsive media queries
  </Tab>
</Tabs>

***

## Figma design best practices

<Card title="Designing in Figma for Email" icon="pen-ruler" href="/creating-emails/figma-design-guide">
  What to use and what to avoid so your Figma frame converts into a clean, reliable email.
</Card>

***

## Advanced Features

### Brand Color Override

Import Figma but apply your brand colors:

```text theme={null}
Import from Figma: [URL]

Replace all blue colors with my brand purple
Apply my brand fonts
Keep the layout structure
```

### Responsive Breakpoints

Migma automatically handles mobile responsiveness, but you can specify:

```text theme={null}
Import from Figma: [URL]

On mobile:
- Stack columns vertically
- Increase font sizes by 10%
- Make CTAs full-width
```

### Component Mapping

Map Figma components to email patterns:

```text theme={null}
Import from Figma: [URL]

Convert:
- "Button Primary" components to my CTA style
- "Card" components to email-safe boxes
- "Icon Grid" to table layout for Outlook
```

***

## Figma Plugins for Migma

### Recommended Figma Plugins

While not required, these plugins enhance your Figma-to-email workflow:

<CardGroup>
  <Card title="Email-Ready Components" icon="puzzle-piece">
    Use email-specific component libraries designed for conversion
  </Card>

  <Card title="Export Helpers" icon="download">
    Batch export images at correct sizes
  </Card>

  <Card title="Contrast Checkers" icon="circle-half-stroke">
    Ensure text readability
  </Card>

  <Card title="Responsive Preview" icon="mobile">
    Preview at 375px mobile width
  </Card>
</CardGroup>

***

## Comparison: Figma vs Other Methods

| Feature | Figma Import | Image Clone | HTML Import |
| - | - | - | - |
| **Accuracy** | ⭐⭐⭐⭐⭐ Highest | ⭐⭐⭐⭐ Very High | ⭐⭐⭐⭐⭐ Exact |
| **Speed** | 60-90 sec | 30-60 sec | Instant |
| **Text Quality** | Perfect | OCR-based | Perfect |
| **Best For** | Original designs | Screenshots | Code migration |
| **Setup** | Figma access | None | HTML source |
| **Flexibility** | High | Medium | Low |

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="Import failed: Cannot access Figma file" icon="lock">
    **Cause:** File not publicly shared or wrong permissions

    **Solution:**

    1. Open Figma file
    2. Click Share → Anyone with link can view
    3. Copy new link and retry
  </Accordion>

  <Accordion title="Fonts don't match" icon="font">
    **Cause:** Custom fonts not available in email clients

    **Solution:**

    * Migma automatically provides web-safe fallbacks
    * Consider using Google Fonts
    * Specify preferred fallback:

    ```text theme={null}
    Use Arial as fallback for custom font
    ```
  </Accordion>

  <Accordion title="Layout broken on mobile" icon="mobile-screen">
    **Cause:** Fixed widths or complex positioning

    **Solution:**

    * Use Figma auto-layout
    * Avoid absolute positioning
    * Request specific mobile behavior:

    ```text theme={null}
    Stack all columns on mobile
    ```
  </Accordion>

  <Accordion title="Colors slightly different" icon="palette">
    **Cause:** Color profile differences or rendering

    **Solution:**

    * Verify hex codes in Figma
    * Manually adjust in refinement:

    ```text theme={null}
    Change all blue to exact hex #2563EB
    ```
  </Accordion>

  <Accordion title="Missing images" icon="image-slash">
    **Cause:** Images not exported or inaccessible

    **Solution:**

    * Ensure images in Figma are fills (not links)
    * Check image export settings
    * Re-upload images if needed
  </Accordion>
</AccordionGroup>

***

## Designer-Developer Workflow

### Collaboration Pattern

<Steps>
  <Step title="Designer Creates">
    Designer builds email in Figma following guidelines
  </Step>

  <Step title="Designer Shares">
    Designer shares Figma link with developer/marketer
  </Step>

  <Step title="Import to Migma">
    Developer/marketer imports to Migma
  </Step>

  <Step title="Review Together">
    Both review converted HTML, make adjustments
  </Step>

  <Step title="Refine in Chat">
    Use Migma chat to make final tweaks collaboratively
  </Step>

  <Step title="Export & Deploy">
    Export to ESP and launch campaign
  </Step>
</Steps>

### Feedback Loop

**Designer → Migma → Developer:**

1. Designer updates Figma
2. Re-import to Migma
3. Compare versions
4. Implement changes

**Time saved:** Hours of manual HTML coding per email

***

## Next Steps

<CardGroup>
  <Card title="Visual Editor" icon="pen-to-square" href="/email-editor/visual-editor">
    Edit Figma imports visually
  </Card>

  <Card title="Email Preflight" icon="clipboard-check" href="/email-editor/email-preflight">
    Run Preflight before send
  </Card>

  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Export to HTML, PNG, or PDF
  </Card>

  <Card title="Image Clone" icon="image" href="/creating-emails/image-clone">
    Clone emails from screenshots
  </Card>
</CardGroup>

***

## Need Help?

<CardGroup>
  <Card title="Figma Templates" icon="layer-group" href="https://migma.ai/figma-templates">
    Download email-ready Figma templates
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Share designs and get feedback
  </Card>

  <Card title="Contact Support" icon="life-ring" href="https://migma.ai/support">
    Get help with complex conversions
  </Card>
</CardGroup>


# Import HTML Email into Migma
Source: https://docs.migma.ai/creating-emails/html-import

Already have an HTML email, a hand-coded template, an export from another tool, or a legacy newsletter that keeps breaking in Outlook.

Already have an HTML email, a hand-coded template, an export from another tool, or a legacy newsletter that keeps breaking in Outlook? Drop it into Migma and it becomes a fully editable, email-safe Migma email. You can keep it exactly as-is, or have it adapted to your brand automatically.

Because every import is rebuilt through Migma's email engine, importing a broken legacy template is also the fastest way to **fix** Outlook and webmail rendering problems.

## How it works

<img alt="The plus add-content dropdown showing the HTML to Email option" title="The + add-content menu" />

<Steps>
  <Step title="Open the add-content menu">
    In the Migma create/chat input, click the **"+"** (plus) button to open the add-content dropdown.
  </Step>

  <Step title="Choose &#x22;HTML to Email&#x22;">
    Select the menu item labeled **HTML to Email**.
  </Step>

  <Step title="Add your HTML">
    **Paste** the HTML code directly, or **drop / upload** a `.html` or `.eml` file.
  </Step>

  <Step title="Preview and import">
    Click **Preview & import**. Migma converts the source into an editable email.
  </Step>

  <Step title="Review & refine">
    Tweak in chat or the visual editor, run Email Preflight, then export.
  </Step>
</Steps>

<Tip>
  Paste is best for a quick snippet or a copied template. Upload a `.eml` when you've saved a real email out of your inbox and want the exact source.
</Tip>

<img alt="The HTML to Email import dialog showing the paste area, browse a file link, and Preview & import button" title="HTML to Email import dialog" />

***

## Agents and API

The same HTML to Email conversion is available from an agent, the API, the SDK, and the CLI. Paste HTML or pass one or more `.html` or `.eml` files. An optional instruction can keep the email as-is or apply the brand. One import can make a series (up to 12). Poll until it finishes, then show the canvas links.

Each converted email is one canvas slot. `emailId` is the handle for that slot. The canvas link opens that email. Edit, send, and export use `emailId`. Agent results omit HTML unless you ask for it.

Use **Import / Convert HTML Email** in MCP when the source already exists. Do not ask the design tool to recreate HTML from a prompt.

[MCP Server](/mcp-server) · [SDK](/sdk) · [CLI](/cli)

***

## Two ways to import

**Exact conversion** keeps your email as-is and makes it Migma-editable and email-safe. Nothing about the design changes. Use this when the template is already the way you want it and you only need it inside Migma.

```text theme={null}
Convert this HTML into an editable Migma email exactly as-is, no design changes
```

**Brand-adapt** keeps the layout and structure but swaps in your project's colors, fonts, and logo so it matches your brand context.

```text theme={null}
Convert this HTML but apply my brand colors, fonts, and logo
```

***

## What happens under the hood

This is not a model guessing at your markup. A deterministic converter parses your HTML and rebuilds it as an editable Migma email.

That single detail is what makes the import dependable:

<CardGroup>
  <Card title="Deterministic" icon="diagram-project">
    A parser reads your HTML and maps it to an editable Migma email. The same input produces the same output every time, no model variance.
  </Card>

  <Card title="Email engine" icon="gears">
    Every import uses the same rendering engine that powers emails built from scratch in Migma.
  </Card>

  <Card title="Email-safe output" icon="shield-check">
    The engine emits email-safe HTML for Gmail, Outlook, Apple Mail, mobile clients, and dark mode review.
  </Card>
</CardGroup>

Because everything flows through that one engine, the output renders reliably across Outlook, Gmail, Apple Mail, and mobile, and stays consistent in dark and light mode (Migma emits explicit `color-scheme` metadata). So if your original template renders fine in some clients but falls apart in Outlook, re-importing it through Migma is the fix: it comes back out as clean, email-safe HTML.

<Check>Tangled, inline-everything legacy markup becomes an editable Migma email</Check>
<Check>Quirks that break specific clients are normalized by the engine</Check>
<Check>The result is fully editable, not a flattened snapshot</Check>

***

## Fixing a broken legacy template

This is the most common reason teams reach for HTML import. The workflow:

<Steps>
  <Step title="Import the broken template">
    Paste or upload the HTML that's misbehaving in Outlook (or anywhere else).
  </Step>

  <Step title="Let the engine rebuild it">
    The deterministic converter rebuilds it as an editable Migma email.
  </Step>

  <Step title="Confirm with Preflight">
    Run Email Preflight to see it across major clients and devices before you send.
  </Step>
</Steps>

<Warning>
  Hand-coded emails often hide client-specific hacks (conditional comments, fixed pixel widths, nested tables) that work in one inbox and break in another. Migma's engine normalizes these, but always confirm the result in Email Preflight before sending to a real list.
</Warning>

***

## After import

Once your email is in Migma, it behaves exactly like one you built from scratch:

<img alt="An imported HTML email open and editable in the Migma visual editor" title="Converted result in the editor" />

<CardGroup>
  <Card title="Refine in chat" icon="comments">
    Ask for changes in plain language: "make the headline larger", "swap the hero image", "tighten the footer spacing".
  </Card>

  <Card title="Edit visually" icon="pen-to-square">
    Click into any block to adjust text, images, colors, and layout directly.
  </Card>

  <Card title="Run Preflight" icon="clipboard-check">
    Test the imported email across major clients and devices before it goes out.
  </Card>

  <Card title="Export anywhere" icon="download">
    Export clean, email-safe HTML for any ESP. No vendor lock-in.
  </Card>
</CardGroup>

***

## HTML import vs other methods

| | HTML to Email | Figma to Email | Clone from Image | Claude Design |
| - | - | - | - | - |
| **Source** | Existing HTML / `.html` / `.eml` | Figma file | Screenshot / mockup | React / JSX `.zip` |
| **Method** | Deterministic converter | Design analysis | Vision + OCR | Deterministic converter |
| **Speed** | Near-instant | 60-90 sec | 30-60 sec | Fast |
| **Text** | Carried over exactly | Exact | OCR-based | Carried over from design |
| **Best for** | Migrating & fixing existing templates | Original Figma designs | Emails you can only see | Emails designed in Claude |
| **Setup** | The HTML source | Figma file access | None | Export the `.zip` |

If you already have the HTML, this is the most faithful path. Your content and structure come across as-is, and you gain email-safe rendering on top. If you only have a picture of an email, use Clone from Image; if you're starting from a design file, use Figma to Email.

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="My paste didn't import" icon="clipboard">
    **Cause:** Partial markup, such as a copied fragment rather than a full document.

    **Solution:** Paste the complete HTML, or save the email as a `.html` / `.eml` file and upload that instead.
  </Accordion>

  <Accordion title="Fonts look different after import" icon="font">
    **Cause:** The original used a font that isn't available across email clients.

    **Solution:** Migma maps to email-safe fallbacks automatically. To pin a specific one, ask in chat:

    ```text theme={null}
    Use Arial as the fallback for the heading font
    ```
  </Accordion>

  <Accordion title="It looked fine before but rendered differently" icon="wand-magic-sparkles">
    **Cause:** The original relied on CSS that some inboxes ignore. The engine rewrites those parts to email-safe equivalents.

    **Solution:** This is expected. The import is optimized to render reliably across clients. Confirm the result in Email Preflight, then refine anything you want to adjust.
  </Accordion>

  <Accordion title="Images are missing" icon="image-slash">
    **Cause:** The HTML referenced images by relative path or from a source that's no longer reachable.

    **Solution:** Use absolute, publicly reachable image URLs in your source, or re-add the images in the visual editor after import.
  </Accordion>
</AccordionGroup>

***

## Related

<CardGroup>
  <Card title="Figma to Email" icon="figma" href="/creating-emails/figma-import">
    Import directly from a Figma design file.
  </Card>

  <Card title="Clone from Image" icon="clone" href="/creating-emails/image-clone">
    Recreate an email from a screenshot or mockup.
  </Card>

  <Card title="Client Compatibility" icon="envelopes-bulk" href="/email-editor/client-compatibility">
    How Migma keeps emails rendering reliably across inboxes.
  </Card>

  <Card title="Email Preflight" icon="clipboard-check" href="/email-editor/email-preflight">
    Test your imported email across major clients and devices.
  </Card>

  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Export clean, email-safe HTML for any ESP.
  </Card>

  <Card title="Claude Design to Email" icon="wand-magic-sparkles" href="/creating-emails/claude-design">
    Import a design built in Claude's design tool via React / JSX.
  </Card>
</CardGroup>


# Clone an Email from an Image
Source: https://docs.migma.ai/creating-emails/image-clone

Upload a screenshot of any email, a competitor's, one you found online, a designer mockup and Migma recreates it as a fully responsive HTML email.

Upload a screenshot of any email, a competitor's, one you found online, a designer mockup and Migma recreates it as a fully responsive HTML email. You can get an exact copy, or have it adapted to your brand automatically.

<Note>
  **Recently improved.** Image-to-email fidelity is closer to the reference. Like every import path, output renders through Migma's email engine for Outlook, webmail, and mobile.
</Note>

## How it works

1. Go to **New Email** in the left sidebar
2. Click **Clone a Screenshot**, or open the **+** menu and choose **Screenshot to Email**
3. Drop, paste, or browse for the screenshot you want to rebuild
4. Choose **Editable copy** or **Brand version**, then create the email

<img alt="The Import from screenshot dialog with upload area and Editable copy or Brand version options" title="Import from screenshot" />

Migma reads the layout, extracts the text, and rebuilds the whole thing in about 30-60 seconds.

***

## Two ways to clone

**Exact clone** — recreates the email exactly as shown, no brand changes. Use this when you want a 1:1 copy or are analyzing a competitor's email.

```text theme={null}
Recreate this email exactly as shown without using project information
```

**Brand-adapted clone** — keeps the layout and structure but swaps in your colors, fonts, and logo. Use this when you like how an email is built but want it to feel like yours.

```text theme={null}
Recreate this email layout but apply my brand colors, fonts, and style
```

***

## What images work best

Migma does best with clean, high-resolution screenshots of full emails. The more of the email it can see, the better the result.

**Great sources:**

* Full email screenshots from Gmail or Outlook
* Designer mockups exported from Figma or Sketch at 2x
* Competitor emails from your inbox

**Supported formats:** JPG, PNG, WebP up to 10MB

<Tip>
  Capture the full email from header to footer in one screenshot. Cropped sections lose context and the result won't be as accurate.
</Tip>

***

## Getting better results

You can combine your image with a text prompt to guide Migma more precisely:

```text theme={null}
Recreate this layout but use our brand colors (purple and gold), replace their
product with our AI email tool, and keep the 3-column feature section.
```

And if the first result isn't quite right, just follow up in chat:

```text theme={null}
The headline should be larger
Move the CTA button above the feature section
Increase spacing between rows
```

Don't try to get it perfect in one shot, it's faster to generate and refine than to write the perfect prompt upfront.

***

## Image clone vs Figma import

| | Image Clone | Figma Import |
| - | - | - |
| **Speed** | 30-60 sec | 60-90 sec |
| **Text accuracy** | OCR-based | Exact |
| **Color accuracy** | Very high | Pixel-perfect |
| **Best for** | Screenshots, mockups, competitor emails | Original Figma designs |
| **Setup needed** | None | Figma file access |

If you have the original Figma file, use the Figma import instead it's more accurate. For everything else, image clone is the faster path.

<Card icon="figma" href="/creating-emails/figma-import" title="Figma Import Guide">
  Import directly from your Figma file for pixel-perfect results
</Card>

***

## What do you want to do next?

<CardGroup>
  <Card icon="pen" href="/email-editor/visual-editor" title="Edit your email">
    Click into any part of your cloned email to tweak text, images, or colors.
  </Card>

  <Card icon="wand-magic-sparkles" href="/content-hub/ai-image-generation" title="Generate images with AI">
    Replace placeholder images with on-brand visuals generated by AI.
  </Card>

  <Card icon="clone" href="/creating-emails/remix-emails" title="Remix emails">
    Reuse and adapt emails you've already made.
  </Card>

  <Card icon="clipboard-check" href="/email-editor/email-preflight" title="Preflight before sending">
    Preflight your cloned email before send.
  </Card>

  <Card icon="file-code" href="/creating-emails/html-import" title="Have the HTML instead?">
    Convert an existing HTML email into a fully compatible Migma email.
  </Card>

  <Card icon="wand-magic-sparkles" href="/creating-emails/claude-design" title="Designed it in Claude?">
    Bring a Claude design straight in via React / JSX import.
  </Card>
</CardGroup>


# Create On-Brand Emails with Migma
Source: https://docs.migma.ai/creating-emails/overview

Create one on-brand email or a complete series in Migma from a goal, Figma design, screenshot, HTML file, saved reference, or AI assistant.

<Frame>
  <img alt="Illustration of four coordinated emails shown together on the Migma canvas" />
</Frame>

Describe the result you need. Migma can prepare one email or a connected series, using your brand, audience, saved references, and approved facts.

## Start with what you have

<CardGroup>
  <Card title="A goal" icon="bullseye" href="/creating-emails/prompt-based-creation">
    Ask for a launch, newsletter, welcome flow, offer, update, receipt, or another clear job.
  </Card>

  <Card title="A full customer journey" icon="route" href="/creating-emails/email-series">
    Describe the journey once. Migma prepares the emails together so the story stays connected.
  </Card>

  <Card title="A design or email" icon="clone" href="/creating-emails/remix-emails">
    Start from Figma, a screenshot, HTML, a Claude design, a past email, or a saved reference.
  </Card>

  <Card title="Another AI tool" icon="comments" href="/integrations/overview">
    Ask from Claude or ChatGPT. Migma keeps the brand, canvas, inbox checks, and final sending controls.
  </Card>
</CardGroup>

## What happens next

<Steps>
  <Step title="Migma prepares the work">
    Copy, design, images, and email structure arrive as an editable draft or series.
  </Step>

  <Step title="You review everything together">
    Compare emails on the canvas. Ask for changes or open one email in the **Visual Editor**.
  </Step>

  <Step title="You check and choose where it goes">
    Run **Email Preflight**, send yourself a test, then send with Migma or export to your email platform.
  </Step>
</Steps>

## Useful starting points

<CardGroup>
  <Card title="Prompt guide" icon="keyboard" href="/creating-emails/prompt-based-creation">
    Say what the reader should understand or do.
  </Card>

  <Card title="Email series" icon="route" href="/creating-emails/email-series">
    Prepare welcome, onboarding, launch, and re-engagement journeys.
  </Card>

  <Card title="Visual canvas" icon="workflow" href="/creating-emails/visual-canvas">
    Review emails, references, and notes in one place.
  </Card>

  <Card title="Import and remix" icon="clone" href="/creating-emails/remix-emails">
    Use existing work without losing editability or inbox safety.
  </Card>
</CardGroup>


# Create Email for a Target Persona
Source: https://docs.migma.ai/creating-emails/persona

A persona is who you're writing for — a real contact, a saved audience, or a tag. It's not who the email gets delivered to (that's set later at the campaign step).

## Overview

A **persona** is who you're writing *for* — a real contact, a saved audience, or a tag. It's not who the email gets *delivered to* (that's set later at the campaign step). Picking a persona tells Migma's AI whose voice, fields, and tone cues to shape the draft around, so the first version you see feels written *for* those people, not generic copy you have to retrofit.

<CardGroup>
  <Card title="Contacts" icon="user">
    Pick one specific person — their real fields show up to the AI for context.
  </Card>

  <Card title="Audiences" icon="users">
    Pick a saved segment — Migma uses the variables that are populated for that group.
  </Card>

  <Card title="Tags" icon="tag">
    Pick everyone with a tag (VIP, Trial, Churned). Same scoping, lighter setup.
  </Card>
</CardGroup>

## How to Use It

<Steps>
  <Step title="Open the Settings menu">
    On the create page, click the settings icon next to the prompt input.
  </Step>

  <Step title="Click 'Persona'">
    A sub-menu opens showing your audiences, tags, and recent contacts. Search to narrow it down.
  </Step>

  <Step title="Pick one">
    Click an audience, tag, or contact. The settings menu now shows a small **1** badge — your draft is now shaped for them.
  </Step>

  <Step title="Write your prompt as usual">
    Type what you want the email to say. Migma silently prepends the persona context so you don't have to repeat "this is for VIP customers" every time.
  </Step>
</Steps>

<Tip>
  To clear the persona, open the sub-menu again and click **Clear selection** at the top, or click the same row a second time.
</Tip>

## Shortcut: Start From a Contact, Audience, or Tag

You don't have to start from the create page. From any **Tag**, **Audience**, or **Contact** row, click the actions menu and pick **Personalise for…** — you'll land on the create page with that persona already selected.

## How Recipient Variables Work

When the persona is an **audience or tag**, Migma checks which subscriber fields are actually populated for that cohort and exposes them to the AI. Fields populated for fewer than 5% of recipients are hidden — so the AI won't suggest variables that don't exist.

For example: if your *VIP* tag has 100% of contacts with `firstName`, `company`, and `industry` filled in, the email might naturally include all three. But if `birthday` is only populated for 2% of VIPs, it won't show up in the draft. You don't have to write "if birthday exists, mention it" — the catalog handles that for you.

When the persona is a **single contact**, Migma uses that person's real values directly (e.g., `firstName=Adam`), so the draft you see in chat looks like the email *that specific person* will receive at send time.

<Note>
  At send time, every recipient still gets their own personalized version — Migma re-renders the email per recipient with their actual data. The persona pick only shapes the draft you write together.
</Note>

## Persona vs. Recipient

These are two different things, and Migma keeps them separate on purpose:

* **Persona** (this page) — who the AI imagines while drafting. Affects voice, suggested variables, and tone.
* **Recipient** — who the email actually gets delivered to. Set at the campaign step when you're ready to send.

You can write a draft with one persona ("VIP customers") and then send it to a different audience at campaign time. The persona just primes the draft.

## FAQ

### Why did one of my variables disappear?

It's likely populated for fewer than 5% of the persona you picked. Either pick a broader cohort, or fill in that field for more contacts. The threshold prevents the AI from suggesting fields most of your recipients don't actually have.

### What if I don't pick a persona?

The email is written generically — Migma uses standard fallback variables (`firstName`, `lastName`, `email`, `company`) and you can wire them up at send time. Picking a persona is always optional.

### Does the persona affect who gets the email?

No. The persona only shapes the draft. The actual recipients are set at the campaign step. You can pick a persona of "VIP customers" and still send the resulting email to your full list — the draft will just lean toward language that resonates with VIPs.

### Does this affect deliverability or rendering?

No. The final email is rendered fresh for every recipient with safe defaults, so each person receives a fully personalized version regardless of which persona you wrote with.

## Related

<CardGroup>
  <Card title="Manage Contacts" icon="user-plus" href="/audience/manage-contacts">
    Build the audiences and tags you'll use as personas.
  </Card>

  <Card title="Prompt-Based Creation" icon="message" href="/creating-emails/prompt-based-creation">
    Best practices for the prompt itself.
  </Card>
</CardGroup>


# Create Emails with AI Prompts
Source: https://docs.migma.ai/creating-emails/prompt-based-creation

Create an on-brand email from a written or dictated prompt, then refine its copy, design, images, and structure in Migma without writing HTML.

You don't need to design anything or write HTML. Type or dictate what you want as if you were explaining it to a colleague. Migma builds a complete, on-brand draft.

## How it works

1. Click **New Email** in the left sidebar
2. Type what you want in the prompt box
3. Hit **Enter**

That's it. Migma reads your brand, writes the copy, and builds the full email. If the result needs work, reply with the change you want.

## Speak instead of typing

1. Select the microphone in the prompt box
2. Speak your brief while Migma adds the words to the box
3. Stop dictation, review the text, then send the prompt

<Frame>
  <img alt="Migma composer showing a microphone recording and a product launch brief ready for review" />
</Frame>

<Note>
  Dictation fills the prompt box. It does not send until you review and submit it.
</Note>

***

## Writing a good prompt

You don't need to overthink this. A good prompt just answers four questions:

**What kind of email is it?** Newsletter, promo, welcome email, announcement, just name it.

**What should be in it?** List the content you want: a discount, a product feature, an event date, a customer story.

**What tone?** Friendly, urgent, professional, playful or just describe the feeling you're going for.

**What should people do?** The action you want readers to take: click a button, book a demo, shop now.

You don't have to answer all four perfectly. Even a rough prompt gets you 80% of the way there.

***

## Prompts you can steal

Not sure where to start? Copy one of these and make it your own.

**Welcome email**

```text theme={null}
Welcome email for new subscribers. Warm tone. One tip to help them get started, and a button to book a demo.
```

**Flash sale**

```text theme={null}
Black Friday sale. 30% off everything, ends Sunday midnight. Make it feel urgent. Big Shop Now button at the top.
```

**Monthly newsletter**

```text theme={null}
Monthly newsletter. Product update, one customer story, reminder about the webinar on the 15th.
```

**Product launch**

```text theme={null}
Launch email for our new AI analytics dashboard. Hero section with product screenshot, 3 key benefits, pricing at $49/mo with a 14-day free trial. Strong CTA to start the trial. Professional and exciting tone.
```

**Re-engagement**

```text theme={null}
Win-back email for subscribers who haven't opened in 90 days. Friendly, not pushy. Remind them what they're missing and offer 20% off to come back.
```

***

## Tips that actually help

<AccordionGroup>
  <Accordion icon="bullseye" title="Start with the action, not the content">
    Ask yourself: what do I want someone to do after reading this? Write that down first, then build the rest of the prompt around it.
  </Accordion>

  <Accordion icon="sitemap" title="Mention structure if you care about it">
    If you want a specific layout — hero image at the top, three feature columns, a big CTA at the bottom — say so. Migma will follow it.
  </Accordion>

  <Accordion icon="info" title="Add context for series or campaigns">
    If this is email #2 in an onboarding sequence, mention that. Migma writes better when it knows where the email fits.
  </Accordion>

  <Accordion icon="arrows-rotate" title="Don't try to write the perfect prompt">
    Generate first, refine second. It's faster to tweak a result than to perfect a prompt upfront.
  </Accordion>
</AccordionGroup>

***

## What do you want to do next?

<CardGroup>
  <Card icon="image" href="/creating-emails/image-clone" title="Clone from an image">
    Screenshot any email you like and Migma recreates it in your brand.
  </Card>

  <Card icon="pen" href="/email-editor/visual-editor" title="Edit your email">
    Click into any part of your email to change text, swap images, or adjust colors.
  </Card>

  <Card icon="figma" href="/creating-emails/figma-import" title="Import from Figma">
    Already have a design? Bring it straight in from Figma.
  </Card>

  <Card icon="chart-bar" href="/campaigns/track-results" title="Send and track results">
    Open rates, click rates, unsubscribes — all in one place after you send.
  </Card>
</CardGroup>


# Remix an Email with Your Brand
Source: https://docs.migma.ai/creating-emails/remix-emails

Found an email you love? Instead of starting from scratch, remix it. Migma takes the layout and structure of any email and rebuilds it with your brand and your content.

Found an email you love? Instead of starting from scratch, remix it. Migma takes the layout and structure of any email and rebuilds it with your brand and your content. Same proven design, your voice.

## How it works

1. Find an email you want to remix
2. Click **Remix** on it
3. Write a prompt describing what you want
4. Hit **Enter**

<img alt="Remix Emails" title="Remix Emails" />

Migma keeps the layout, sections, and visual structure from the original. Everything else, your colors, fonts, logo, and copy, comes from your brand and prompt.

***

## Where to find emails to remix

**Trending** — Browse [migma.ai/trending](https://migma.ai/trending) to see popular public emails. Hover over any card to preview it, filter by type (newsletter, promo, product launch), and hit **Remix** when you find one you like.

**Your emails** — Go to **Templates** and open the **Your Emails** tab. Any email you've previously made can be remixed into something new.

**Competitors** — If you've set up [competitor tracking](/creating-emails/competitor-tracking), their emails show up under the **Competitors** tab in **Templates**.

***

## Good times to use Remix

* You saw an email with a great layout and want something similar for your brand
* You want to reuse a past campaign with updated content
* You want to try a seasonal version of something that already worked
* You want to test two different approaches to the same campaign

***

## What do you want to do next?

<CardGroup>
  <Card icon="fire" href="https://migma.ai/trending" title="Browse trending emails">
    Find popular emails to remix from the community.
  </Card>

  <Card icon="binoculars" href="/creating-emails/competitor-tracking" title="Track competitors">
    Collect competitor emails and remix their best designs.
  </Card>

  <Card icon="pen" href="/email-editor/visual-editor" title="Edit your email">
    Click into any part of your remixed email to adjust text, images, or colors.
  </Card>

  <Card icon="chart-bar" href="/campaigns/track-results" title="Track results">
    See how your remixed campaign performs after sending.
  </Card>
</CardGroup>


# Organize Email Work on the Visual Canvas
Source: https://docs.migma.ai/creating-emails/visual-canvas

Plan and review email work on Migma's Visual Canvas with complete series, references, comments, past versions, and targeted Mark Select edits.

The Visual Canvas shows every email in a conversation together. Compare a series, pin references beside it, leave feedback, and open one email when you need a closer edit.

## What you can see

<CardGroup>
  <Card title="Emails and series" icon="envelopes-bulk">
    Compare complete emails side by side and move them around the canvas.
  </Card>

  <Card title="References" icon="thumbtack">
    Keep HTML, screenshots, saved emails, and inspiration near the work they inform.
  </Card>

  <Card title="Comments" icon="comments">
    Leave feedback on an email or an open area, mention teammates, and resolve the thread when done.
  </Card>

  <Card title="Past versions" icon="clock-rotate-left">
    Preview an earlier canvas without changing the latest version, then restore it when needed.
  </Card>
</CardGroup>

## Point at one area

Use **Mark Select** when your request concerns one part of an email or reference.

<Steps>
  <Step title="Stay on the canvas overview">
    Mark Select appears when the canvas is open and has something you can point at. Visual Editor appears after you open one email, so the two controls do not show together.
  </Step>

  <Step title="Choose Mark Select">
    Select **Mark Select** in the message box, then drag a box over the area you mean.
  </Step>

  <Step title="Add your instruction">
    The selected area appears inside your message. Add a request such as "make this shorter" or "use this footer on email 2," then send.
  </Step>
</Steps>

<Frame>
  <img alt="Migma canvas with a rectangular Mark Select area and selected-area thumbnails attached to the message" />
</Frame>

You can select more than one area in the same message. Remove a selection before sending when it is no longer relevant. Review the result to confirm the edit stayed within the scope you intended.

## Add a reference

Right-click an open area of the canvas to add supporting material.

| Reference | Use it for |
| - | - |
| **HTML** | Preview an existing email, then convert it into an editable Migma email when you want to work on it. |
| **Screenshot or image** | Keep a visual direction, product image, or layout example beside your drafts. |
| **Saved or competitor email** | Point to a section you want Migma to learn from without changing the original. |

See [HTML to Email](/creating-emails/html-import) when you want to turn pinned HTML into editable work.

## Review with your team

<Steps>
  <Step title="Add a comment">
    Choose the comment control and click where the feedback belongs. You can also right-click an open area and choose **Comment here**.
  </Step>

  <Step title="Mention someone">
    Type `@`, choose a teammate, then post the comment. Replies stay attached to the same place.
  </Step>

  <Step title="Resolve it">
    Resolve the thread when the feedback is handled. Reopen it when more work is needed.
  </Step>
</Steps>

Unresolved canvas comments can guide the next design change. Resolved comments stay visible without guiding later edits.

## Open one email

Choose **Edit email** from the email card you want. The canvas moves into a focused email view where you can use design chat, Visual Editor, Email Preflight, and Publish.

Use **Duplicate in new chat** for one email or **Duplicate series** for the whole sequence when you want another direction. Rename changes the label in Migma, not the email subject.

## Use version history

<Steps>
  <Step title="Open history">
    Choose a saved version from the canvas history.
  </Step>

  <Step title="Preview it">
    The earlier version opens read-only. Choose **Back to latest** to leave without changing anything.
  </Step>

  <Step title="Restore when needed">
    Review the confirmation, then restore. Later canvas changes leave the current view, but remain recoverable from history.
  </Step>
</Steps>

<Frame>
  <img alt="Canvas version history listing earlier versions and restore controls" />
</Frame>

## Work together live

When teammates open the same brand, Migma shows their presence, cursors, and canvas changes. See [Real-time collaboration](/collaboration/realtime) for roles and shared editing.

## Next

<CardGroup>
  <Card title="Edit one email" icon="pen" href="/email-editor/visual-editor">
    Use Visual Editor for direct text, image, button, link, and layout changes.
  </Card>

  <Card title="Create an email series" icon="layer-group" href="/creating-emails/email-series">
    Prepare a connected sequence and review every email together.
  </Card>
</CardGroup>


# Turn a YouTube Video into an Email
Source: https://docs.migma.ai/creating-emails/youtube-to-email

Turn a YouTube video into an on-brand Migma email by pasting its URL, choosing the message and audience, then reviewing and editing the generated draft.

## Overview

Paste any YouTube URL into the chat editor and Migma will extract the video content to generate an email. This works through prompts — describe what kind of email you want alongside the video link.

***

## How to Use

<Steps>
  <Step title="Copy a YouTube URL">
    Copy the URL of any public YouTube video.
  </Step>

  <Step title="Paste in your prompt">
    Include the URL in your chat prompt along with instructions:

    ```text theme={null}
    Watch this YouTube video and create an email summary:
    https://youtube.com/watch?v=VIDEO_ID

    Include the main takeaways and a CTA to watch the full video.
    ```
  </Step>

  <Step title="Review and send">
    Migma generates an email based on the video content. Edit as needed and export.
  </Step>
</Steps>

***

## Example Prompts

<Tabs>
  <Tab title="Webinar Recap">
    ```text theme={null}
    Create a recap email from this webinar recording:
    https://youtube.com/watch?v=ABC123

    Include 5 key takeaways and a link to the recording.
    Tone: Professional
    ```
  </Tab>

  <Tab title="Product Demo">
    ```text theme={null}
    Generate a product launch email from this demo:
    https://youtube.com/watch?v=DEMO456

    Highlight new features and benefits.
    ```
  </Tab>

  <Tab title="Tutorial">
    ```text theme={null}
    Create an email announcing this new tutorial:
    https://youtube.com/watch?v=XYZ789

    Include what viewers will learn and a CTA to watch.
    ```
  </Tab>
</Tabs>

***

## Tips

* Be specific about what you want extracted (key points, quotes, features, etc.)
* Specify the email tone and structure in your prompt
* Works best with structured content: presentations, demos, interviews, tutorials
* Public videos with clear audio produce the best results

***

## Next Steps

<CardGroup>
  <Card title="Prompt-Based Creation" icon="wand-magic-sparkles" href="/creating-emails/prompt-based-creation">
    More prompting techniques
  </Card>

  <Card title="Send a Campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Send your email to your audience
  </Card>
</CardGroup>


# Email Client Compatibility for Outlook and Mobile
Source: https://docs.migma.ai/email-editor/client-compatibility

Learn how Migma keeps emails readable across Outlook, Gmail, Apple Mail, webmail, mobile devices, light and dark mode, and accessible inboxes.

<Frame>
  <img alt="One Migma email shown in Outlook, Gmail, Apple Mail, mobile, and dark mode with Email Preflight ready" />
</Frame>

Migma emails are made for inboxes, not web pages. The same email-safe build is used whether you started with a prompt, Figma, HTML, a screenshot, or Claude.

## What Migma prepares for

<CardGroup>
  <Card title="Outlook" icon="envelope-open-text">
    Extra layout care keeps sections, spacing, buttons, and backgrounds stable in desktop Outlook.
  </Card>

  <Card title="Gmail and other webmail" icon="envelope">
    Email-safe styles keep the layout readable in Gmail, Yahoo, Outlook on the web, and similar inboxes.
  </Card>

  <Card title="Phones and tablets" icon="mobile-screen">
    Content resizes and stacks so it remains easy to read and tap on smaller screens.
  </Card>

  <Card title="Light and dark mode" icon="circle-half-stroke">
    Text, key colors, buttons, and logos get protection against common color changes.
  </Card>
</CardGroup>

## Light mode and dark mode

Inbox apps can change colors on their own. Without care, dark text can disappear, a logo can lose contrast, or a button can become hard to read.

Migma adds light and dark color information and keeps important brand colors where inbox apps allow it. **Email Preflight** lets you see the result before sending.

<Note>
  Inbox apps do not all use the same dark-mode rules. Preview both modes instead of assuming they will look identical.
</Note>

## Check before you send

<Steps>
  <Step title="Open the email you want to send">
    Focus the finished email on your Migma canvas.
  </Step>

  <Step title="Choose Email Preflight">
    Review inbox previews, layout warnings, links, writing, and common sending problems.
  </Step>

  <Step title="Fix anything important">
    Make the change yourself or use **Fix with AI**, then run Preflight again.
  </Step>

  <Step title="Send yourself a test">
    Choose **Send Test Email** and open it on the devices and inboxes your audience uses.
  </Step>
</Steps>

## Why small differences still happen

Outlook, Gmail, Apple Mail, and mobile apps do not render email in exactly the same way. Some block images, replace fonts, or change colors.

Migma aims for the result that matters: stable layout, readable content, working buttons, and a design that still feels like your brand.

## After you export

Migma hands off the same email-safe HTML you reviewed. Your email platform may add its own wrapper, fill variables, or apply sending rules, so open the exported result and send one final test from that platform.

## Next

<CardGroup>
  <Card title="Run Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    See every check and how to read the result.
  </Card>

  <Card title="Export your email" icon="download" href="/email-editor/export-options">
    Move the reviewed email to your preferred platform.
  </Card>

  <Card title="Make your first email" icon="paper-plane" href="/get-started/create-first-email">
    Follow the full flow, including a test to your own inbox.
  </Card>

  <Card title="Use Outlook" icon="envelope-open-text" href="/email-editor/outlook-export">
    Learn the Outlook handoff when direct sending is not ready.
  </Card>
</CardGroup>


# Choose How to Edit an Email in Migma
Source: https://docs.migma.ai/email-editor/editing-your-email

Choose between design chat, Mark Select, and the Visual Editor to change a whole email, one selected area, or individual content and styles.

Migma gives you three ways to change an email. Start with the smallest one that fits the job.

| Need | Use |
| - | - |
| Change the whole email, copy, tone, or structure | **Design chat** |
| Point at one area while viewing the canvas | **Mark Select** |
| Change text, images, buttons, links, colors, or spacing directly | **Visual Editor** |

## Ask in design chat

Describe the result you want in plain language. Chat works best for first drafts, large rewrites, new sections, and changes across a full series.

```text theme={null}
Make all three welcome emails shorter and more direct.
```

```text theme={null}
Add one customer quote before the main button.
```

## Point with Mark Select

Keep the canvas overview open, choose **Mark Select** in the message box, then drag over the exact area you mean. The selected area appears inside your message.

Mark Select is available on the canvas. Visual Editor is available after one email is open, so they do not appear together.

See [Point at one area](/creating-emails/visual-canvas#point-at-one-area).

## Open one email

Choose **Edit email** from the email card you want. This opens the focused email view and keeps later changes tied to that email.

From here you can:

* Ask for another change in chat.
* Start **Visual Editor**.
* Run **Email Preflight**.
* Send yourself a test.
* Open **Publish** when the email is ready.

## Edit directly with Visual Editor

Start **Visual Editor**, then click the text, image, button, or section you want to change. Use the side panel for content and style controls. Choose **Keep changes** when done or **Discard** to leave the email unchanged.

The [complete Visual Editor tutorial](/email-editor/visual-editor) covers email-wide settings, images, buttons, layers, mobile review, and Preflight.

## Check before handoff

Use **Email Preflight** and **Send Test Email** in the health bar below the focused email. Check desktop, mobile, light mode, dark mode, links, and the real test message before a large send.

## Send, export, or use the API

Open **Publish** for the final handoff:

* **Send** uses a Migma campaign and an opted-in audience.
* **Export** moves the reviewed email to a file or connected email platform.
* **API** gives developers the focused email and its required values.

See [Send or Export](/email-editor/export-options).

## Review with teammates

Use **Share** for brand access. Teammates can work on the same canvas, see live changes, and leave anchored comments based on their role.

See [Real-time collaboration](/collaboration/realtime).


# Run Email Preflight Checks
Source: https://docs.migma.ai/email-editor/email-preflight

Run Migma Email Preflight to preview major inboxes and check responsive layouts, links, writing, spam signals, and delivery risks before sending.

Email Preflight shows how your finished email behaves in real inboxes before you send or export it.

<Frame>
  <img alt="Illustration showing a Migma email in Outlook, Gmail, Apple Mail, mobile, and dark mode with Preflight checks" />
</Frame>

## Run Preflight

<Steps>
  <Step title="Open the email">
    Focus the email you want to check on the Migma canvas.
  </Step>

  <Step title="Choose Email Preflight">
    Find **Email Preflight** in the health bar below the email.
  </Step>

  <Step title="Review each result">
    Migma adds results as checks finish. Open warnings or errors to see what needs attention.
  </Step>

  <Step title="Fix and run it again">
    Choose **Fix with AI** for help, or edit the email yourself. Run Preflight again after changes.
  </Step>
</Steps>

## What it checks

<CardGroup>
  <Card title="Inbox previews" icon="devices">
    See the finished email in major inboxes, on desktop and mobile, in light and dark mode.
  </Card>

  <Card title="Links" icon="link">
    Find broken or unreachable links before readers click them.
  </Card>

  <Card title="Writing" icon="spell-check">
    Catch spelling, grammar, language, and basic content problems.
  </Card>

  <Card title="Spam and delivery risk" icon="shield-check">
    Review wording, link density, sender details, and other signals that can hurt delivery.
  </Card>
</CardGroup>

## Read the results

<Check>Green means the check passed.</Check>
<Warning>Yellow means review the result before sending.</Warning>
<Warning>Red means fix the problem before sending.</Warning>

<Note>
  Preflight reduces avoidable problems. It cannot promise inbox placement. Your sending domain, audience permission, list health, and message still matter.
</Note>

## Send yourself a test

After Preflight, choose **Send Test Email** in the same health bar. Open the message on devices you use, click important links, and check the sender name and reply address.

Test emails use Migma's sender, so you can review a draft before adding your own sending domain.

## Next

<CardGroup>
  <Card title="Email compatibility" icon="inbox" href="/email-editor/client-compatibility">
    Learn why the same email can look different across inboxes.
  </Card>

  <Card title="Sending rules" icon="envelope-circle-check" href="/get-started/what-you-can-send">
    Make sure every recipient expects your email.
  </Card>

  <Card title="Send or export" icon="paper-plane" href="/email-editor/export-options">
    Choose where the finished email should go.
  </Card>

  <Card title="Add a sending domain" icon="globe" href="/sending-domains/add-domain">
    Send larger campaigns from an address owned by your brand.
  </Card>
</CardGroup>


# Email Viewer & Code View
Source: https://docs.migma.ai/email-editor/email-viewer

After Migma generates an email from your prompt, the email viewer lets you preview the result, inspect the code, and switch between display modes.

## Overview

After Migma generates an email from your prompt, the email viewer lets you preview the result, inspect the code, and switch between display modes. Refine your email by sending follow-up prompts in the chat.

***

## Email Viewer Modes

<Tabs>
  <Tab title="Preview">
    See your email as subscribers will see it. Toggle between **desktop** and **mobile** layouts, and switch between **light** and **dark** mode to check how the design holds up.
  </Tab>

  <Tab title="HTML Code">
    View the generated HTML source with syntax highlighting and line numbers. Copy the code to your clipboard or download the file.
  </Tab>
</Tabs>

***

## Refining Your Email

Migma is conversational — edit your email by sending follow-up prompts in the chat:

* "Make the CTA button red"
* "Add a section about our new pricing"
* "Remove the footer image"
* "Make the headline shorter"

Each response generates an updated email version. Previous versions remain accessible in the conversation.

***

## Generation Options

Customize how your email is generated before prompting:

* **Design style** — Memphis, Brutalism, Neobrutalism, Y2K, Pop Art, Bauhaus, and more
* **Email DNA** — Match the style of platforms like Loops, Mailchimp, Beehiiv, ConvertKit, or Substack
* **Tone** — Professional, Casual, Urgent, Luxury, Playful, Humorous, and more
* **AI model** — Choose between different AI providers
* **Speed** — Toggle between quality and speed

***

## A/B Test Variants

When building a [campaign](/campaigns/overview) with A/B testing enabled:

1. Generate multiple email versions from different prompts
2. In the campaign wizard, assign each version to a variant (A, B, C, etc.)
3. Set the test audience size
4. The winning variant is sent to the remaining audience

Variants are selected from your generated emails — each variant uses a separate email conversation.

***

## Subject & Preheader Override

In the campaign wizard, you can override the AI-generated subject line and preheader text:

* **Subject line** — up to 80 characters
* **Preheader** — preview text shown in inbox list views

***

## Next Steps

<CardGroup>
  <Card title="Create an Email" icon="wand-magic-sparkles" href="/creating-emails/prompt-based-creation">
    Generate emails from prompts
  </Card>

  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Export to HTML, PNG, PDF, and ESPs
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Test before sending
  </Card>

  <Card title="Send a Campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Send your email to your audience
  </Card>
</CardGroup>


# Send or Export Migma Emails
Source: https://docs.migma.ai/email-editor/export-options

Send a reviewed email with Migma, export it to an email platform, download HTML, PNG, or PDF, or use it through the API, SDK, CLI, and agents.

Open **Publish** when the email is ready. Send with Migma, hand it to your email platform, download a file, or use it from an app.

## Choose the outcome

<CardGroup>
  <Card title="Send with Migma" icon="paper-plane" href="/campaigns/send-campaign">
    Choose an opted-in audience, sender, and time. Migma owns the campaign and results.
  </Card>

  <Card title="Use your email platform" icon="arrow-up-tray" href="/integrations/platform-integrations">
    Move reviewed work to Mailchimp, Omnisend, Brevo, an existing HubSpot connection, or Klaviyo as HTML or a beta editable template.
  </Card>

  <Card title="Download a file" icon="download">
    Get HTML for another email tool, PNG for a visual preview, or PDF for sharing and review.
  </Card>

  <Card title="Use it from an app" icon="code" href="/api-reference/introduction">
    Use the API, SDK, CLI, or Migma agent tools when email handoff belongs in an automated workflow.
  </Card>
</CardGroup>

## Export an email

<Steps>
  <Step title="Focus the email">
    When a series is open, choose the exact email you want to send or export.
  </Step>

  <Step title="Run the final checks">
    Use **Email Preflight** and send yourself a test before handoff.
  </Step>

  <Step title="Open Publish">
    Choose **Send**, **Export**, or **API**.
  </Step>

  <Step title="Finish in the destination">
    For a platform export, open the new template or draft there. Confirm the audience, sender, subject, variables, and timing before sending.
  </Step>
</Steps>

## Export translated emails

When an email has multiple translations, **Export language** appears in **Publish → Export**. Choose a language to preview and export that version.

To get every translation at once, click **Download all languages (.zip)** below the language picker. The ZIP contains a separate HTML file for each language, with its language code in the filename. Unzip the download, then import each HTML file as a separate template in Klaviyo or your other email platform.

You can download all languages without choosing one first. If any translation cannot be prepared, no ZIP downloads; try again after the error.

## Email platforms

Connect platforms per brand from **Settings → Integrations → Marketing platforms**. In Publish, connected Mailchimp, Klaviyo, and HubSpot accounts support direct sending as well as export. Omnisend and Brevo use export handoff: finish review and sending in that platform. Exporting a template or draft does not send an email.

<CardGroup>
  <Card title="Mailchimp" icon="envelope" href="/integrations/mailchimp">
    Export a template or draft campaign.
  </Card>

  <Card title="Klaviyo" icon="database" href="/integrations/klaviyo">
    Export an HTML template, or choose **Adapt for Klaviyo editor (Beta)** for an editable version. Use HTML when a layout cannot be adapted.
  </Card>

  <Card title="Omnisend" icon="envelope" href="/integrations/omnisend">
    Export a draft campaign for final review in Omnisend.
  </Card>

  <Card title="Brevo" icon="paper-plane" href="/integrations/brevo">
    Export a reusable Brevo template.
  </Card>

  <Card title="HubSpot" icon="building-office" href="/integrations/hubspot">
    Export draft work through an existing HubSpot connection. New connections are not available.
  </Card>
</CardGroup>

## What stays with the email

Migma exports the reviewed email-safe HTML, including responsive layout and dark-mode information. Personal details such as a customer name or order number remain variables for the destination to fill.

Email platforms can still add wrappers, change variables, or apply their own sending rules. Open the exported result and send a real test from the final platform before a large campaign.

## File formats

<AccordionGroup>
  <Accordion title="HTML" icon="code">
    Use the compiled email in another platform. Choose readable or smaller minified HTML when that option appears.
  </Accordion>

  <Accordion title="PNG" icon="image">
    Use a full-email image for review, presentations, or a portfolio. A PNG is not a sendable email template.
  </Accordion>

  <Accordion title="PDF" icon="file-pdf">
    Share or archive a document copy of the email. A PDF is not a sendable email template.
  </Accordion>
</AccordionGroup>

## Next

<CardGroup>
  <Card title="Choose an email platform" icon="plug" href="/integrations/platform-integrations">
    Compare export and sending destinations.
  </Card>

  <Card title="Check real inboxes" icon="mobile" href="/email-editor/client-compatibility">
    Review Outlook, Gmail, mobile, light mode, and dark mode.
  </Card>

  <Card title="Run Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Find links, content, inbox, and sending problems before handoff.
  </Card>

  <Card title="Use Outlook" icon="envelope-open-text" href="/email-editor/outlook-export">
    Hand off HTML through Outlook when direct sending is not ready.
  </Card>
</CardGroup>


# Export to Outlook Without Domain Setup
Source: https://docs.migma.ai/email-editor/outlook-export

Export a reviewed Migma email to Outlook for a one-off send when a business cannot approve a sending domain during a trial, while preserving layout.

If your business cannot approve a Migma sending domain or ESP integration during a trial, you can still use Migma to design and test the email, then place the exported email into an Outlook message manually.

<Info>
  You do not need domain approval to export the email design. Domain setup is only needed when Migma sends the campaign for you.
</Info>

<Warning>
  Manual Outlook sending uses your Outlook mailbox. Migma cannot manage tracking, unsubscribe handling, suppression lists, deliverability logs, or campaign analytics for messages sent this way.
</Warning>

***

## Client-ready answer

Yes. If domain integration cannot be approved for a trial, create and review the email in Migma, export the HTML, then insert the rendered email into Outlook. Best path is:

1. Run Email Preflight in Migma.
2. Export the email as HTML from **Publish → Export → HTML**.
3. Open the exported HTML in a browser and copy the rendered email.
4. Paste it into an Outlook compose window.
5. Send a test to yourself before sending to recipients.

For classic Outlook on Windows, you can also insert the HTML file directly with **Insert -> Attach File -> Insert as Text**.

***

## Before you export

<Steps>
  <Step title="Confirm consent">
    Send only to people who gave permission to receive your email. Migma does not allow cold email or purchased lists. See [sending rules](/get-started/what-you-can-send).
  </Step>

  <Step title="Run Email Preflight">
    Review spam risk, link checks, Outlook rendering, dark mode, and client compatibility before exporting. See [Email Preflight](/email-editor/email-preflight).
  </Step>

  <Step title="Check compliance content">
    For commercial email, keep your business identification, postal address where required, and unsubscribe or preference instructions in the email body.
  </Step>
</Steps>

***

## Export from Migma

<Steps>
  <Step title="Open the email">
    Open the email or series slot you want to send.
  </Step>

  <Step title="Open Publish">
    Click **Publish** in the email viewer toolbar.
  </Step>

  <Step title="Choose HTML export">
    Choose **Export**, then **HTML**.
  </Step>

  <Step title="Copy or download">
    Copy the HTML or download the `.html` file. Downloading is easiest when you plan to open it in a browser or insert it into classic Outlook.
  </Step>
</Steps>

<Tip>
  Do not paste raw HTML code into Outlook's message body. Outlook will usually show it as text. Open the HTML first, then copy the rendered email.
</Tip>

***

## Add the email to Outlook

<Tabs>
  <Tab title="Outlook web or new Outlook">
    Use this path when Outlook does not show **Insert as Text**.

    <Steps>
      <Step title="Open the HTML file">
        Open the exported `.html` file in a browser.
      </Step>

      <Step title="Copy the rendered email">
        Select the rendered email in the browser and copy it.
      </Step>

      <Step title="Paste into Outlook">
        Open a new Outlook message and paste the rendered email into the body.
      </Step>

      <Step title="Send a test">
        Send to yourself first. Check layout, links, images, and dark mode if your audience uses Outlook.
      </Step>
    </Steps>
  </Tab>

  <Tab title="Classic Outlook for Windows">
    Classic Outlook can insert an HTML file as the message body.

    <Steps>
      <Step title="Create a new message">
        Open classic Outlook for Windows and create a new email.
      </Step>

      <Step title="Insert the HTML file">
        Go to **Insert -> Attach File**, choose the exported `.html` file, then use the arrow beside **Insert** and choose **Insert as Text**.
      </Step>

      <Step title="Review the message">
        Add your subject line, recipients, and any final edits.
      </Step>

      <Step title="Send a test">
        Send to yourself and at least one Outlook inbox before sending to recipients.
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Note>
  New Outlook, Outlook web, and Outlook for Mac may not support **Insert as Text**. Use the browser copy and paste method in those clients.
</Note>

***

## What may change in Outlook

Outlook is strict about email HTML, especially desktop Outlook (Word rendering). Migma exports production HTML built for real inboxes. Outlook or Microsoft 365 policies can still adjust the message after you paste or insert it.

Common changes:

* Outlook may remove unsupported CSS or scripts.
* Your company policy may block external images until recipients click to download them.
* Images need public URLs. Local image file paths will not work for recipients.
* Some spacing can shift after Outlook converts the pasted content.
* Reply and forward views can look different from the original sent message.

Run [Email Client Compatibility](/email-editor/client-compatibility) checks in Migma and send a real Outlook test before client approval.

***

## When to use this workaround

Use Outlook export when:

* You are blocked from approving DNS or a sending domain during a trial.
* You need a client to preview or approve a Migma-designed email.
* You are sending a small, manual test from your own mailbox.
* Your organization requires Outlook as the sending surface.

Do not use this workaround for bulk marketing sends. For production campaigns, use a verified [sending domain](/sending-domains/overview), an approved [ESP integration](/integrations/email-service-providers), or Migma campaign sending so unsubscribe handling, suppression lists, logs, and analytics stay connected.

***

## Related pages

<CardGroup>
  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Export HTML, PNG, PDF, or ESP templates.
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Review spam risk, links, compatibility, and deliverability before exporting.
  </Card>

  <Card title="Email Client Compatibility" icon="mobile" href="/email-editor/client-compatibility">
    Understand Outlook, dark mode, and inbox rendering.
  </Card>

  <Card title="Sending Rules" icon="shield-check" href="/get-started/what-you-can-send">
    Permission-based email policy and no-cold-email rules.
  </Card>
</CardGroup>


# Visual Email Editor
Source: https://docs.migma.ai/email-editor/visual-editor

Edit text, images, buttons, links, colors, spacing, variables, sections, and whole-email settings directly in Migma without changing HTML.

Open an email and select **Visual Editor**. Click any text, image, button, or section to edit it. You do not need to edit HTML.

<Tip>
  Use [design chat](/email-editor/editing-your-email#ask-in-design-chat) to ask for changes to the whole email. Use [Mark Select](#use-mark-select-to-point-at-something) to point at a specific area. Use **Visual Editor** when you want to make the change yourself.
</Tip>

## How to use the Visual Editor

<Steps>
  <Step title="Open one email">
    Select an email, then select **Edit email**. Visual Editor is available after the email opens.

    <Frame>
      <img alt="Illustration of Migma canvas with four emails and one email ready to open" />
    </Frame>
  </Step>

  <Step title="Open Visual Editor">
    Select **Visual Editor** in the message box. You can also select the cursor button next to the email.

    <Frame>
      <video aria-label="Migma Visual Editor selecting and reshaping an image directly on the email canvas" />
    </Frame>
  </Step>

  <Step title="Change settings for the whole email">
    Select **Email** at the top of the editor. You can change the width, font, text size, and background. You can also review variables and links.

    <Frame>
      <img alt="Illustration of Visual Editor email settings with width, font, background, variables, and links" />
    </Frame>

    <Warning>
      Fix links marked **No destination**, **Placeholder**, or **Not allowed in email** before you export or send the email. Add fallback text for variables that may be empty.
    </Warning>
  </Step>

  <Step title="Edit text">
    Select a heading or paragraph. Type in the email. Use the controls to change the font, size, weight, color, alignment, background, corners, or spacing.

    <Frame>
      <video aria-label="Editing a heading, changing its color, and adding a first-name fallback in Migma Visual Editor" />
    </Frame>
  </Step>

  <Step title="Edit an image">
    Select an image. You can replace it, crop it, remove its background, or describe an edit. You can also add alt text and a link. Select **Add caption** to add a small line of text under the image, then click it to write your own.

    <Frame>
      <img alt="Migma Visual Editor with a selected email image beside the Adjust image crop and exposure controls" />
    </Frame>
  </Step>

  <Step title="Choose a new image">
    Upload, drag, or paste a file. You can also select **Your images**, **Stock images**, or **GIF images**.

    <Frame>
      <img alt="Illustration of Migma image picker with upload, Your images, Stock images, and GIF images" />
    </Frame>

    <Note>
      GIFs work best as content images. Background images use a still frame in email clients that do not animate them.
    </Note>
  </Step>

  <Step title="Crop or shape the image">
    Select **Adjust**. Crop, move, or change the shape of the image. You can also add a sticker or text. Select **Done** to apply the changes.

    <Frame>
      <img alt="Illustration of Adjust image with crop, shape, sticker, text, Reset, Cancel, and Done controls" />
    </Frame>
  </Step>

  <Step title="Edit a button">
    Select a button. Change its text and link. Select **Filled**, **Outline**, or **Text link**. You can also change its width, colors, corners, and spacing.

    <Frame>
      <img alt="Illustration of selected email button with link, appearance, width, color, corners, and spacing controls" />
    </Frame>
  </Step>

  <Step title="Find elements with Layers">
    Open **Layers** when you cannot select something directly. The list includes sections, columns, images, headings, paragraphs, spacers, and dividers. Select a name to open it.

    <Frame>
      <img alt="Illustration of Migma Layers panel showing email sections, images, headings, paragraphs, spacers, and dividers" />
    </Frame>

    The toolbar next to the selected element lets you move, add, copy, save, comment on, or remove it.

    Select the plus icon to open **Add block**. **Basic** adds a single **Heading**, **Text**, **Image**, **Button**, **Divider**, **Spacer**, or **Social links**. **Columns** adds a **2 columns**, **3 columns**, **1/3 + 2/3**, or **2×2 grid** layout with placeholder text in each cell. Columns stack on narrow screens. The new block lands next to the selected element.
  </Step>

  <Step title="Save or discard changes">
    Select **Keep changes** to save. Select **Discard** to close without saving.
  </Step>

  <Step title="Check the phone preview">
    Select the phone preview. Check text size, image crops, button width, spacing, and reading order.

    <Frame>
      <img alt="Illustration of Migma mobile email preview with the Visual Editor controls" />
    </Frame>
  </Step>

  <Step title="Run Email Preflight">
    Open **Email Preflight** to check device previews, links, grammar, CSS support, and delivery issues. Review light and dark inbox previews. Fix any problems, then send a test email to yourself.

    <Frame>
      <img alt="Illustration of Migma Email Preflight with device previews, CSS compatibility, link validator, grammar, deliverability, and inbox previews" />
    </Frame>

    Use **Send Test Email** before you send the final email.
  </Step>
</Steps>

## Use Mark Select to point at something

**Mark Select** is a separate tool. Use it when you want to show Migma what to change and describe the result in words.

1. On the full canvas, select **Mark Select** in the message box or press **R**
2. Drag around the area you want to change
3. A cropped preview of the area is added to your message
4. Write the requested change next to the preview; add more selections if needed
5. Send the message; open the result in Visual Editor if you want to make more changes yourself

Press **Escape** or select **Mark Select** again to stop.

<Frame>
  <video aria-label="Using Mark Select to draw around email sections and attach them to a Migma prompt" />
</Frame>

## Highlight or cover part of an image

Use image effects to highlight or hide part of an image.

1. Select an image, select **Adjust**, then open **Effects**
2. Select **Spotlight** to dim the area outside your selection, or **Cover area** to place color over it
3. Select **Rectangle** or **Oval**, then draw, move, or resize the area
4. Set the color and strength, select **Done**, then save your Visual Editor changes

Select **Whole image** to apply the effect to the full image. At full strength, **Cover area** hides the selected area.

<Frame>
  <video aria-label="Migma Visual Editor selecting an image and applying a rectangular cover area from the Effects panel" />
</Frame>

## Save and reuse a section

You can save a section and use it in another email.

1. Select the top-level section in the email or **Layers**
2. Select **Save to library** in the toolbar next to it
3. Open **Sections**, then **Saved**, and select the section to insert it

<Frame>
  <img alt="Migma Visual Editor showing the section bookmark control and the Saved sections library" />
</Frame>

<Note>
  Migma saves the whole section, not an item inside it. Manage saved sections under **Brand Workspace → Design references → Emails → Sections**.
</Note>

## A simple workflow

1. Create or import an email, then open it
2. Edit the heading, body text, and button text in Visual Editor
3. Replace or crop images, then check their alt text and links
4. Use Mark Select for changes you want to describe
5. Use Layers when an element is difficult to select
6. Check the phone preview
7. Save your changes, run Email Preflight, and send yourself a test

## Check before you send

Use the desktop and phone previews to check spacing, text size, image crops, and buttons. Use Email Preflight to review links, common inboxes, and compatibility. Check both light and dark mode.

Before sending, read the copy, open each link, check fallback text, and send yourself a test.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Visual Editor is missing" icon="eye-slash">
    Open one email first. Visual Editor is not shown on the full canvas. If the email is read-only, ask Migma chat to create an editable version.
  </Accordion>

  <Accordion title="I cannot select the part I need" icon="layers">
    Open **Layers** and select the part by name. This also works for empty sections, spacers, columns, and parts outside the visible area.
  </Accordion>

  <Accordion title="My image does not fit" icon="crop-simple">
    Select the image, select **Adjust**, then crop or move it. Select **Reset** to return to the original crop.
  </Accordion>

  <Accordion title="A name or link is blank" icon="brackets-curly">
    Select **Email**, check **Variables**, and add a fallback value. Then review every destination under **Links**.
  </Accordion>

  <Accordion title="I changed the wrong thing" icon="rotate-left">
    Use undo if it is available. If you have not saved the edit, select **Discard** and open Visual Editor again.
  </Accordion>
</AccordionGroup>

## Next

<CardGroup>
  <Card icon="clipboard-check" href="/email-editor/email-preflight" title="Check your email">
    Check desktop, mobile, light mode, dark mode, links, and inbox compatibility.
  </Card>

  <Card icon="image" href="/content-hub/ai-image-generation" title="Create an image">
    Create an image and add it to the email.
  </Card>

  <Card icon="arrow-up-right" href="/email-editor/export-options" title="Move it to your email platform">
    Download the email or send it to a connected email platform.
  </Card>

  <Card icon="comments" href="/collaboration/realtime" title="Review with your team">
    Share the email, leave feedback, and edit together.
  </Card>
</CardGroup>


# Track Customer Events with the Migma API
Source: https://docs.migma.ai/events

Events let your backend tell Migma when a customer does something that matters, such as completing a purchase, starting a trial, or requesting a refund.

## Overview

Events let your backend tell Migma when a customer does something that matters, such as completing a purchase, starting a trial, or requesting a refund. Migma stores each event against a contact and uses purchase events to attribute revenue back to the email a recipient clicked.

Common uses:

* Report a purchase so Migma can credit the email that drove it
* Record trial starts, upgrades, or cancellations as customer activity
* Send negative amounts for refunds and cancellations so revenue stays honest
* Feed order and profile context into a contact without changing their subscription

<Info>
  Events are inbound: your system reports them to Migma. This is the opposite direction from [webhooks](/webhooks), which are outbound notifications Migma sends to you.
</Info>

Reporting events requires an API key with the `audience:write` permission.

## Quick start

Report a completed purchase with an order identifier and a value. Migma stores the event and, when the value and order identifier are present, records it as a conversion.

```bash theme={null}
curl https://api.migma.ai/v1/events \
  -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: order-10432" \
  -d '{
    "projectId": "665f1e928c2a9e4d8f123123",
    "name": "purchase.completed",
    "identifiers": {
      "email": "casey@example.com",
      "externalOrderId": "order-10432"
    },
    "properties": {
      "value": 49.99,
      "currency": "USD"
    },
    "occurredAt": "2026-07-03T12:34:56.789Z"
  }'
```

The response is synchronous:

```json theme={null}
{
  "stored": true,
  "eventId": "668f2f7b9a9b6d84f1b2c345",
  "dedupeKey": "order-10432"
}
```

## Event fields

| Field | Required | Meaning |
| - | - | - |
| `projectId` | Yes | The brand the event belongs to. |
| `name` | Yes | The event name, such as `purchase.completed` or `trial.started`. |
| `identifiers` | Yes | How Migma matches the event to a contact. See below. |
| `profile` | No | Contact metadata to update: `firstName`, `lastName`, `phone`, `country`, `language`, `customFields`. |
| `properties` | No | Structured event data. Up to 16KB, 50 top-level keys, and 4 levels deep. |
| `occurredAt` | No | When the event happened, in ISO 8601 format. Defaults to receipt time. |
| `dedupeKey` | No | A key to make the event replay-safe. See [Replay safety](#replay-safety). |

### Identifiers

Provide at least one way to match the event to a contact:

| Identifier | Use |
| - | - |
| `email` | Match or create a contact by email address. |
| `subscriberId` | Match an existing contact by its Migma ID. |
| `externalCustomerId` | Your own customer ID, stored for cross-referencing. |
| `externalCheckoutId` | Your checkout or session ID. |
| `externalOrderId` | Your order ID. Required for conversion attribution. |

### Consent stays intact

Events never change subscription status. An event never opts anyone in, resubscribes an unsubscribed contact, or makes a non-sendable contact sendable. When you include `profile`, Migma updates contact metadata only. To manage subscription status, use the Contacts API.

## Replay safety

Networks retry. Migma gives you two ways to make sure a retried report is stored once.

* Single events: send an `Idempotency-Key` header. A retry with the same key returns the original result instead of storing a second event.
* Batches: set a per-event `dedupeKey` on each row. A request-level `Idempotency-Key` header on a batch returns `400`, because one key cannot cover many events.

Raw events are retained for 90 days.

## Batches

Report up to 500 events in one request with `POST /v1/events/batch`. Each row is validated on its own, so a batch can partially succeed: valid rows are stored, invalid rows are reported back, and duplicates are counted.

```bash theme={null}
curl https://api.migma.ai/v1/events/batch \
  -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "665f1e928c2a9e4d8f123123",
    "events": [
      {
        "name": "purchase.completed",
        "identifiers": { "email": "casey@example.com", "externalOrderId": "order-10432" },
        "properties": { "value": 49.99, "currency": "USD" },
        "dedupeKey": "order-10432"
      },
      {
        "name": "trial.started",
        "identifiers": { "email": "jordan@example.com" },
        "dedupeKey": "trial-jordan-1"
      }
    ]
  }'
```

The response reports each row:

```json theme={null}
{
  "accepted": 1,
  "duplicates": 1,
  "results": [
    { "stored": true, "eventId": "668f30a19a9b6d84f1b2c400", "dedupeKey": "order-10432" },
    { "stored": false, "duplicate": true, "dedupeKey": "trial-jordan-1" }
  ],
  "invalid": []
}
```

| Field | Meaning |
| - | - |
| `accepted` | Rows stored on this request. |
| `duplicates` | Rows skipped because their `dedupeKey` was already stored. |
| `results` | Per-row outcome, in request order. |
| `invalid` | Rows that failed validation, with the reason for each. |

## Conversion attribution

An event becomes a conversion when it carries both `identifiers.externalOrderId` and a numeric `properties.value` in major units, such as `49.99`. Set `properties.currency` to an ISO code; it defaults to `USD`.

Migma attributes the conversion to the last email the recipient clicked within the previous five days, and credits that email once.

Refunds and cancellations keep the numbers honest. When an event name contains `refund` or `cancelled`, Migma records a negative amount, so returned revenue is subtracted rather than counted.

```bash theme={null}
curl https://api.migma.ai/v1/events \
  -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: refund-10432" \
  -d '{
    "projectId": "665f1e928c2a9e4d8f123123",
    "name": "order.refunded",
    "identifiers": {
      "email": "casey@example.com",
      "externalOrderId": "order-10432"
    },
    "properties": {
      "value": 49.99,
      "currency": "USD"
    }
  }'
```

### Revenue in campaign stats

When conversions have been attributed to a campaign, `GET /v1/campaigns/{id}/stats` includes a conversion block, and the same figures appear in campaign analytics in the app when it ships:

```json theme={null}
{
  "conversions": 12,
  "revenue": 584.88,
  "currency": "USD",
  "source": "events"
}
```

The conversion block is omitted entirely when nothing has been reported, so a campaign with no attributed revenue shows no conversion figures rather than fake zeros.

<CardGroup>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Review event endpoints, schemas, and permissions.
  </Card>

  <Card title="Webhooks" icon="bell" href="/webhooks">
    Receive outbound notifications when Migma activity happens.
  </Card>
</CardGroup>


# Frequently Asked Questions
Source: https://docs.migma.ai/faq

Find answers about Migma's AI email creation, editing, sending, deliverability, integrations, custom domains, billing, security, and team workflows.

## Platform & Capabilities

<AccordionGroup>
  <Accordion title="Why is Migma better than ChatGPT or Claude for email?">
    ChatGPT and Claude are excellent general-purpose AI tools, but they're not built for email. Here's what happens when you use general AI for email creation:

    **The Problems:**

    * Emails often land in spam folders (image-heavy designs they can't optimize)
    * Layouts frequently break in Outlook (they don't test rendering)
    * Mobile rendering issues are common (no responsive testing)
    * Brand colors and fonts are rarely accurate (no brand memory)
    * Significant manual fixing required per email
    * Can't test across email clients
    * Break layouts when you iterate ("make the button blue" regenerates everything)
    * No email-specific knowledge (spam filters, CAN-SPAM, deliverability)

    **What Migma Does Differently:**

    **1. Email Preflight Testing** - Runs client previews and compatibility checks (Gmail, Outlook, Apple Mail, Yahoo, and more) before you send. Catches spam triggers, compliance issues, mobile rendering problems, and compatibility bugs. ChatGPT can't do this.

    **2. Brand Memory** - Learn your brand once (colors, fonts, logos, tone), use it forever. Every email is automatically on-brand. No re-explaining, no uploading assets repeatedly.

    **3. Visual Editor** - Click any element to edit directly without regenerating the entire email. Change button colors, adjust spacing, modify text. Keep what works, fix what doesn't. With ChatGPT, every change = full regeneration = unpredictable results.

    **4. On-Brand Image Generation** - Creates images with your exact brand colors, logo placement, and typography. Automatically optimized for email (100KB). ChatGPT gives you generic images you still need to edit in Photoshop.

    **5. Email-specific rendering** - Renders to table-based HTML for Outlook, webmail, and mobile. Handles Outlook Word rendering, dark mode, and client-safe CSS. ChatGPT outputs generic HTML that often breaks.

    **6. Live Content Integration** - Connects to Shopify, Notion, your CMS to pull real product data, prices, inventory. ChatGPT invents fake information you have to manually replace.

    **7. Multi-Language with Layout Preservation** - Translates to any language while automatically adjusting layouts (Spanish text is 20% longer, German 30%). ChatGPT translates text but breaks your layout.

    **The Time Difference:**

    * General AI workflow: Creation + fixing layouts + testing can easily take over an hour per email
    * Migma workflow: Describe what you want, generate, and preflight in minutes

    **Bottom Line:** ChatGPT is a Swiss Army knife (great for 100 things, perfect for none). Migma is a scalpel built specifically for email. Use ChatGPT for blog posts and brainstorming. Use Migma when your email needs to actually work.
  </Accordion>

  <Accordion title="How is Migma different from other email marketing platforms?">
    Migma is an email workspace for brand teams. Unlike platforms like Mailchimp or Klaviyo that start with sending infrastructure, Migma starts with source imports, brand context, editing, preflight, and export.

    Start from a prompt, Figma, screenshot, HTML, URL, or reference. Migma keeps brand context, editing, review checks, and delivery options in one place.

    You can then export the HTML or integrate with your preferred sending platform (Klaviyo, Mailchimp, AWS SES, Resend, etc.).
  </Accordion>

  <Accordion title="What is Migma and how does it work?">
    **Migma.ai** is an email workspace that turns source context into editable email HTML. Here's how it works:

    * **Brand Import:** Provide your website URL and Migma imports brand elements: logos, colors, fonts, and content.
    * **AI Prompting:** Use simple prompts like "Announce our new product using this blog post" to instruct the AI.
    * **Content Generation:** The AI generates both email copy and layout based on your brand identity and input.
    * **Editing & Refinement:** Use the built-in editor to refine results or iterate through chat history.
    * **Export & Send:** Export HTML or send directly through integrated email service providers.

    Features include AI image generation, Figma-to-email conversion, screenshot cloning, and multi-language support.
  </Accordion>

  <Accordion title="Can I send emails with Migma?">
    Yes. Migma supports three sending paths:

    **1. Migma sending:** Verify a custom sending domain, choose an audience, and send or schedule a campaign directly from Migma.

    **2. Connected delivery provider:** Route delivery through Amazon SES, Resend, SendGrid, or Mailgun while keeping creation, review, and campaign controls in Migma.

    **3. Export:** Export reviewed HTML, MJML, React, or a platform-specific template to Mailchimp, Klaviyo, HubSpot, Omnisend, Brevo, or another service.

    You choose the path that fits your sending infrastructure. See [Email service providers](/integrations/email-service-providers) and [Export options](/email-editor/export-options).
  </Accordion>

  <Accordion title="Can I use Migma for cold outreach?">
    **No.** Migma is for permission-based marketing email only, not cold outreach, scraped lists, or purchased lists.

    Use Migma for newsletters, product updates, lifecycle email, and campaigns to contacts who opted in to hear from you. Read [Permission-based sending](/get-started/what-you-can-send) and [Acceptable use](/legal/acceptable-use) for full guidance.
  </Accordion>
</AccordionGroup>

## AI & Email Creation

<AccordionGroup>
  <Accordion title="How does Migma's AI help with email creation?">
    Migma's AI streamlines the entire email creation process:

    * **Content Generation:** Creates compelling copy based on your prompts and brand voice
    * **Layout Design:** Automatically structures content with professional email design patterns
    * **Image Generation:** Generates on-brand images using AI (or you can upload your own)
    * **Brand Consistency:** Maintains your brand identity across all generated emails
    * **Content Fetching:** Pulls content from URLs (blog posts, product pages) to populate emails
    * **Multi-format Input:** Converts Figma designs, screenshots, YouTube videos, or plain text into emails
    * **Iteration:** Refine and regenerate sections through conversational prompts

    The AI understands email best practices, ensuring proper HTML structure, mobile responsiveness, and compatibility across email clients.
  </Accordion>

  <Accordion title="How does Migma handle email personalization?">
    Migma supports several levels of personalization:

    **Brand Personalization:** The AI learns your brand voice, style, and design preferences from your website and brand guidelines.

    **Content Personalization:** You can provide specific prompts, reference materials, and content links to customize each email's message.

    **Brand Guidelines:** Upload past emails, style guides, and brand materials to train Migma on your unique voice and preferences.

    **Dynamic Content:** When sending through integrated platforms, you can add personalization tokens (first name, company, etc.) before export.

    **Template Remixing:** Reuse successful email structures with new content for consistent but varied campaigns.
  </Accordion>

  <Accordion title="Can I use my past emails to train Migma?">
    Yes! This is one of Migma's most powerful features.

    Head to your brand settings, open the **Brand Guidelines** section, and upload your previous emails, style guides, and brand materials. Migma will analyze these examples to learn your brand's style, tone, and design patterns.

    You can also add successful emails to your brand guidelines directly from the editor by clicking "info" then "Add to Brand Guidelines."

    The more examples you provide, the better Migma becomes at matching your unique brand voice and design preferences.
  </Accordion>

  <Accordion title="Can I upload and use custom fonts?">
    Yes! Migma supports custom font uploads so you can use your exact brand typography in emails.

    **How to Upload Custom Fonts:**

    1. Go to your brand settings
    2. Open **Visual Identity** and select the **Typography** tab
    3. Upload your custom font files (TTF, OTF, WOFF formats)
    4. Migma will automatically apply your fonts to generated emails

    **Important for Email Fonts:**
    While you can use custom fonts, email rendering has limitations:

    * **Web-safe fallbacks:** Migma automatically includes fallback fonts (Arial, Helvetica, Georgia) for email clients that don't support custom fonts
    * **Email client support:** Modern email clients (Apple Mail, iOS Mail, some versions of Outlook) support custom fonts, but older clients fall back to web-safe alternatives
    * **Best practice:** Use custom fonts for headings and branded elements, with web-safe fonts as fallbacks for body text

    **Font Hosting:** Migma handles font hosting and proper email-compatible implementation automatically. You don't need to worry about @font-face declarations or CDN setup.

    **Google Fonts:** You can also reference any Google Font by name, and Migma will implement it with proper email client compatibility.

    The result: Your emails maintain brand consistency across all devices while ensuring readability even when custom fonts aren't supported.
  </Accordion>
</AccordionGroup>

## Email Deliverability & Technical

<AccordionGroup>
  <Accordion title="How does Migma handle email deliverability?">
    Migma generates clean, standards-compliant HTML that follows email best practices:

    * **Cross-Client Rendering:** Battle-tested rendering tuned for broad email-client compatibility
    * **Email Client Testing:** All generated emails work across major email clients (Gmail, Outlook, Apple Mail, Yahoo, etc.)
    * **Responsive Design:** Emails automatically adapt to mobile and desktop views
    * **Clean Code:** Produces optimized HTML without bloat or compatibility issues
    * **Email Preflight:** Built-in checker to identify potential deliverability issues before sending

    For actual delivery (inbox placement, domain reputation, etc.), that depends on your sending infrastructure (AWS SES, Resend, etc.) and sender practices. Migma ensures your email code won't cause technical deliverability issues.
  </Accordion>

  <Accordion title="Can I use my own sending domain with Migma?">
    Yes. Add a domain you own, publish the DNS records Migma provides, and wait for verification before production sends. Migma configures the authentication needed for built-in sending, including DKIM, SPF alignment, DMARC guidance, and a custom MAIL FROM return path.

    You can also use a domain already verified with a connected delivery provider such as Amazon SES, Resend, SendGrid, or Mailgun. A Migma managed address is available for initial testing, but a verified custom domain is the recommended production path.

    This means:

    * You maintain control over your sender reputation
    * You use your own domain authentication (SPF, DKIM, DMARC)
    * Recipients see emails from your domain, not Migma

    Follow [Set up sending domains](/sending-domains/overview) for the complete workflow.
  </Accordion>

  <Accordion title="Should I send from my main domain or a subdomain?">
    Both work, and the choice is about reputation, not features.

    **The main domain is the default.** Migma verifies `yourbrand.com` itself as a sender, so recipients see `news@yourbrand.com`. Campaigns send from it.

    **Keep receipts separate.** Migma also verifies `notify.yourbrand.com` for transactional email, so a campaign that lands badly cannot hurt delivery of receipts and password resets.

    When adding a sender, pick the identity first. `hello@yourbrand.com` needs the main domain verified. `hello@notify.yourbrand.com` needs the transactional identity verified. SES does not let one inherit the other. Publish then lists every sendable From you saved. If a domain you connected earlier still has `send.yourbrand.com`, that marketing address keeps working. Unsubscribe handling, suppression, and compliance always follow the type of email you send, not the address you pick. See [Sending Domains](/sending-domains/overview) for setup.
  </Accordion>

  <Accordion title="What email clients are supported?">
    Migma-generated emails are compatible with all major email clients:

    * **Webmail:** Gmail, Outlook.com, Yahoo Mail, AOL Mail, iCloud Mail
    * **Desktop:** Outlook (Windows/Mac), Apple Mail, Thunderbird
    * **Mobile:** iOS Mail, Gmail App, Outlook App, Samsung Mail

    We test across all major clients to ensure broad compatibility and modern rendering standards. The email preflight tool also helps identify any potential rendering issues before you send.
  </Accordion>

  <Accordion title="Does Migma handle unsubscribes?">
    Yes. When you use Migma's audience management and sending features, we automatically:

    * Add proper unsubscribe headers (List-Unsubscribe)
    * Include unsubscribe links in email footers
    * Manage unsubscribe requests and update your audience lists
    * Ensure compliance with email regulations (CAN-SPAM, GDPR)

    If you export HTML to use with another platform, you'll need to ensure that platform handles unsubscribes appropriately.
  </Accordion>

  <Accordion title="Does Migma support dark mode for emails?">
    Yes. Migma automatically generates emails with dark mode support across all major email clients.

    **Why Dark Mode Matters:**

    Based on our case studies, emails with proper dark mode implementation:

    * **Better Consistency:** Ensure your emails look professional whether recipients use light or dark mode
    * **Improved Deliverability:** Emails optimized for dark mode show higher inbox placement rates
    * **Better User Experience:** Over 60% of users prefer dark mode. Your emails should respect that preference

    **What Migma Does:**

    * Automatically adapts colors for dark mode without washing out your brand
    * Tests dark mode rendering across Gmail, Outlook, Apple Mail, and other clients
    * Maintains readability and visual hierarchy in both light and dark modes
    * Prevents common dark mode issues (invisible text, broken layouts, poor contrast)

    All Migma-generated emails include dark mode support by default. No extra configuration needed.
  </Accordion>

  <Accordion title="Why do Migma emails outperform plain-text emails for deliverability?">
    Many believe plain-text emails are better for deliverability, especially for cold outreach. Our case studies show the opposite.

    **The Plain-Text Problem:**

    * **Low Effort = Spam Flags:** Plain-text mass emails are easy to generate, so spam filters treat them suspiciously
    * **No Engagement Signals:** Email providers track engagement (opens, clicks, time spent reading). Plain-text provides minimal engagement data
    * **Generic Patterns:** Most spam and low-quality cold outreach uses plain text, creating negative associations
    * **Landing in Spam:** Our research shows plain-text cold outreach emails have significantly higher spam folder placement

    **Why Migma Emails Land in Inboxes:**

    * **High-Quality Signals:** Well-designed, branded HTML emails signal legitimate business communication
    * **Professional Standards:** Proper HTML structure, clean code, and email best practices trigger positive deliverability signals
    * **Better Engagement:** Recipients spend more time with well-designed emails, sending positive signals to email providers
    * **Proven Results:** Our case studies demonstrate Migma-generated emails consistently achieve higher inbox placement rates than plain-text alternatives

    **Bottom Line:** The "plain text = better deliverability" myth comes from the idea that simpler is better. In reality, email providers have evolved to recognize quality, professional emails as legitimate communication. Migma's intelligent, high-quality email generation helps you stand out as a real business, not a mass spammer.

    For marketing emails, product announcements, and customer communications, professionally designed HTML emails significantly outperform plain text.
  </Accordion>
</AccordionGroup>

## Integrations & Workflow

<AccordionGroup>
  <Accordion title="Can Migma work with my existing email framework?">
    Yes. Migma works with your existing workflow:

    **Brand Guidelines:** Upload your existing email templates, style guides, and brand materials. Migma learns your framework and generates emails that match your established patterns.

    **ESP Integration:** Connect with Klaviyo, Mailchimp, and other email service providers. Export Migma-generated HTML directly to your existing campaigns.

    **Custom Frameworks:** If you use a custom email framework or component library, add examples to your brand guidelines so Migma can replicate your structure.

    **Brand Consistency:** Migma maintains your brand's style, tone, and design patterns across all generated emails.
  </Accordion>

  <Accordion title="How does the Figma to Email feature work?">
    The Figma to Email feature converts Figma designs into editable email HTML:

    1. **Copy Figma URL:** Copy the frame URL from your Figma design
    2. **Paste into Migma:** Paste the URL into Migma's Figma import tool
    3. **AI Conversion:** Our AI analyzes the design and converts it to email-compatible HTML
    4. **Preservation:** Styling, layout, spacing, colors, and visual elements are preserved
    5. **Edit & Send:** Refine in the editor and send or export

    This works with complex designs, custom fonts, and responsive layouts. The AI converts design elements into email-safe HTML/CSS that works across email clients.
  </Accordion>

  <Accordion title="Can I share my generated emails publicly?">
    Yes. You can generate shareable links for any email you create. Useful for:

    * Getting client approval
    * Sharing with team members
    * Preview before sending
    * Portfolio showcases

    Just click the "Share" button in the email editor to create a public link.
  </Accordion>
</AccordionGroup>

## Getting Started

<AccordionGroup>
  <Accordion title="How does pricing work?">
    Migma offers **two plans**: **Premium** and **Business**. New accounts can start a **7-day free trial** on their chosen plan before billing begins.

    AI generation uses Migma-managed model access. You can connect your own sending provider, such as AWS SES, depending on your setup.

    See the [pricing page](https://migma.ai/pricing) for current prices and limits.
  </Accordion>

  <Accordion title="Do you offer Enterprise solutions?">
    Yes. Our Enterprise plan includes:

    * Unlimited email generation
    * Custom AI model access
    * Dedicated support team
    * Custom branding options
    * Full API access
    * Team collaboration features
    * Advanced integrations

    [Contact our sales team](mailto:sales@migma.ai) to discuss your specific enterprise needs.
  </Accordion>
</AccordionGroup>

## Still have questions?

If you can't find the answer you're looking for, please contact our support team or visit our [Discord community](https://discord.gg/migma) for help.

<CardGroup>
  <Card title="Contact Support" icon="headset" href="mailto:support@migma.ai">
    Get help from our support team
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/migma">
    Connect with the community
  </Card>
</CardGroup>


# Billing & Plans
Source: https://docs.migma.ai/get-started/billing-and-plans

Migma has two subscription plans — Premium and Business. Payment is due at checkout. Free trials are currently unavailable.

## Pricing Plans

Migma has **two subscription plans** — **Premium** and **Business**. **Payment is due at checkout.** Free trials are currently unavailable.

<CardGroup>
  <Card title="Premium" icon="crown">
    \*\*$99.99/month** or $950/year

    * Personal workspace
    * 100 AI emails per day
    * 200,000 emails/month sending
    * AI image & GIF generation
    * Export to Mailchimp & more
    * Figma design import
    * Compatibility testing
  </Card>

  <Card title="Business" icon="building-columns">
    \*\*$299/month** or $2,748/year

    * Team workspace
    * 2 editor seats included
    * Real-time collaboration
    * Unlimited AI emails
    * 3M emails/month sending
    * Unlimited AI images & GIFs
    * Best AI models
    * Unlimited brand kits
    * Priority support
  </Card>
</CardGroup>

<Info>
  Need SSO, custom sending limits, or compliance packages? [Contact us](mailto:sales@migma.ai) about **Enterprise**.
</Info>

<Info>
  **Global Deliverability (add-on).** See your email from the mailbox side: cross-provider campaign analytics, pre-send inbox placement testing, and domain and IP blocklist reputation monitoring. Available on any paid plan. [Explore Global Deliverability](/advanced-features/global-deliverability) or [contact us](mailto:sales@migma.ai?subject=Global%20Deliverability) to add it.
</Info>

<Frame>
  <img alt="Settings and usage tracking" />
</Frame>

***

## Workspaces, seats, and real-time

Billing follows the **active workspace**. Your personal workspace uses your own plan. A team workspace uses the owner's plan, seats, and sending quota.

<CardGroup>
  <Card title="Workspaces" icon="building" href="/collaboration/workspaces">
    Switch between personal and team workspaces. Owners pay for the workspace plan, sending quota, and seats.
  </Card>

  <Card title="Seats" icon="chair" href="/collaboration/seats">
    Business includes 2 editor seats. Commenters and viewers are free. Extra editor seats can be added as the team grows.
  </Card>

  <Card title="Real-time" icon="satellite-dish" href="/collaboration/realtime">
    Presence, cursors, canvas sync, and generation awareness turn on automatically when teammates open the same brand.
  </Card>
</CardGroup>

<Info>
  Joining a paid team workspace does not require a paid personal plan. If the workspace owner gives you a seat, you get Business editor access in that workspace.
</Info>

***

## Starting Your Subscription

Migma does not currently offer free trials. Choose **Premium** or **Business**, review the price and billing period in checkout, and confirm payment to start your subscription.

Your first payment is due at checkout. Your subscription then renews monthly or annually, depending on the billing period you choose.

***

## Managing Your Subscription

### View your current plan

<Steps>
  <Step title="Open Settings">
    Click your profile icon in the top-right corner and select **Settings**.
  </Step>

  <Step title="Go to Billing">
    Navigate to the **Billing** section to see your current plan, usage, and next billing date.
  </Step>
</Steps>

### Upgrade or downgrade

<AccordionGroup>
  <Accordion title="Upgrading your plan" icon="arrow-up">
    Upgrades take effect immediately. You'll be charged a prorated amount for the remainder of your current billing period.

    1. Go to **Settings → Billing**
    2. Click **Manage billing**
    3. Select your new plan
    4. Confirm the change

    You'll get instant access to all features of the higher plan.
  </Accordion>

  <Accordion title="Downgrading your plan" icon="arrow-down">
    Downgrades are scheduled for the end of your current billing period. You'll keep access to your current plan's features until then.

    1. Go to **Settings → Billing**
    2. Click **Manage billing**
    3. Select the lower plan
    4. Confirm the change

    Your new plan takes effect at the start of your next billing cycle.
  </Accordion>

  <Accordion title="Switching between monthly and annual" icon="calendar">
    Save money by switching to annual billing:

    * **Premium:** \$950/year (save \~21% vs. monthly)
    * **Business:** \$2,748/year (save \~23% vs. monthly)

    Go to **Settings → Billing → Manage billing** to switch your billing cycle.
  </Accordion>
</AccordionGroup>

***

## Canceling Your Subscription

You can cancel your subscription at any time. Here's what to expect:

<Steps>
  <Step title="Go to Billing settings">
    Navigate to **Settings → Billing** in your Migma dashboard.
  </Step>

  <Step title="Click Cancel subscription">
    Select the cancel option. You'll be asked to confirm.
  </Step>

  <Step title="Keep access until period ends">
    Your subscription remains active until the end of your current billing period. You won't be charged again.
  </Step>

  <Step title="Subscription ends">
    After your billing period ends, your paid subscription ends. You can resubscribe anytime from **Settings → Billing**.
  </Step>
</Steps>

<Info>
  **Changed your mind?** You can reactivate your subscription at any time before your billing period ends by clicking **Reactivate subscription** in your billing settings. No need to re-enter payment details.
</Info>

***

## Refunds

If you were charged unexpectedly or aren't satisfied with the service, contact our support team:

<CardGroup>
  <Card title="Email support" icon="envelope" href="mailto:support@migma.ai">
    [support@migma.ai](mailto:support@migma.ai)
  </Card>

  <Card title="In-app chat" icon="comments">
    Click the chat icon in the bottom-right corner of your dashboard
  </Card>
</CardGroup>

Our team reviews refund requests on a case-by-case basis and is happy to help resolve any billing concerns.

***

## Payment & Security

<AccordionGroup>
  <Accordion title="What payment methods are accepted?" icon="credit-card">
    Migma accepts all major credit and debit cards:

    * Visa
    * Mastercard
    * American Express
    * Discover

    All payments are securely processed through **Stripe**. We never store your full card details.
  </Accordion>

  <Accordion title="How do I update my payment method?" icon="wallet">
    1. Go to **Settings → Billing**
    2. Click **Manage billing**
    3. Update your payment method in the Stripe portal

    Your new payment method will be used for future charges.
  </Accordion>

  <Accordion title="Where can I find my invoices?" icon="receipt">
    All invoices and payment history are available in the Stripe billing portal:

    1. Go to **Settings → Billing**
    2. Click **Manage billing**
    3. View your invoice history and download receipts
  </Accordion>

  <Accordion title="Is my payment information secure?" icon="shield-check">
    Yes. Migma uses **Stripe** for payment processing, which is PCI DSS Level 1 certified — the highest level of security certification in the payments industry. Your card details are encrypted and never touch our servers.
  </Accordion>
</AccordionGroup>

***

## Common Billing Questions

<AccordionGroup>
  <Accordion title="Is there a free trial?">
    Free trials are currently unavailable. Payment is required when you subscribe, including for new accounts.
  </Accordion>

  <Accordion title="When will I be charged?">
    Your first payment is due when you confirm checkout. Later payments follow your monthly or annual billing cycle.
  </Accordion>

  <Accordion title="What happens if my payment fails?">
    If a payment fails, Stripe will retry the charge a few times. You'll receive email notifications about the failed payment. If the payment continues to fail, your subscription will be canceled.

    Update your payment method in **Settings → Billing → Manage billing** to avoid interruptions.
  </Accordion>

  <Accordion title="Can I pause my subscription instead of canceling?">
    Currently, Migma doesn't offer a pause option. You can cancel your subscription and resubscribe later when you're ready. Your account data is retained for 90 days after cancellation.
  </Accordion>

  <Accordion title="Do I lose my data if I cancel?">
    No — your data is retained for **90 days** after cancellation. During this time, you can resubscribe and pick up where you left off. After 90 days, data may be permanently deleted.
  </Accordion>
</AccordionGroup>

***

## Next Steps

<CardGroup>
  <Card title="Create your first email" icon="wand-magic-sparkles" href="/get-started/create-first-email">
    Start generating emails in under 5 minutes
  </Card>

  <Card title="Import your brand" icon="palette" href="/get-started/configure-brand">
    Set up your brand identity for on-brand emails
  </Card>

  <Card title="Contact support" icon="life-ring" href="mailto:support@migma.ai">
    Get help with any billing questions
  </Card>
</CardGroup>


# Set Up Your Brand in Migma
Source: https://docs.migma.ai/get-started/configure-brand

Set up a Migma brand from your website, then review its logos, colors, fonts, voice, products, company details, references, and AI instructions.

Migma uses your website, brand settings, and saved references to understand how your emails should look and sound.

<Frame>
  <img alt="Illustration showing a website added to Migma and the brand colors and type found from it" />
</Frame>

## Add your website

<Steps>
  <Step title="Open My Brands">
    Go to [My Brands](https://migma.ai/projects) and choose **New Brand**.
  </Step>

  <Step title="Add your homepage">
    Paste the main website for your brand. Migma checks the public pages that help it understand your products, style, writing, and company details.
  </Step>

  <Step title="Let Migma learn in the background">
    You can close the window. Your brand stays in progress while Migma gathers useful details.
  </Step>

  <Step title="Review your brand">
    Open the brand when it is ready. Check the logo, colors, type, company details, and saved guidance before making your first email.
  </Step>
</Steps>

## What Migma learns

* **How it looks:** logos, colors, fonts, images, and common design patterns.
* **How it sounds:** product language, headlines, calls to action, and writing style.
* **What it says:** products, positioning, company details, footer information, and social links.

## Make it more yours

Open **All brand settings** whenever you want to correct or add something.

<AccordionGroup>
  <Accordion title="Brand Guidelines" icon="book-open">
    Add product facts, approved messages, offers, or words Migma should use. Website findings can appear here too. Anything you add yourself stays in place when Migma refreshes website details.
  </Accordion>

  <Accordion title="Design references" icon="images">
    Save emails and images that show the style you want. Migma can use them as design direction without copying them word for word. Under **Your emails**, star any email you have already made to use it as a reference, or paste in or upload one from elsewhere.
  </Accordion>

  <Accordion title="AI Instructions" icon="message-pen">
    Add lasting preferences such as “Keep headlines short” or “Never use playful language.”
  </Accordion>

  <Accordion title="Visual Identity" icon="swatchbook">
    Review logos, colors, button and container shapes, and font choices. Change anything that does not match your brand.
  </Accordion>
</AccordionGroup>

## Use your brand while designing

Inside an email, select the brand logo on the canvas rail. The brand workspace opens without leaving your draft. You can review brand information, palette, fonts, references, images, instructions, memories, and connected tools.

<Tip>
  If an email feels off, tell Migma what should change. Save useful long-term guidance in **AI Instructions** or a strong finished email in **Design references**.
</Tip>

## If your website does not work

<AccordionGroup>
  <Accordion title="Migma cannot read the website" icon="triangle-exclamation">
    Use the public homepage rather than a page behind a login. If the site still cannot be read, create the brand and add logos, colors, company details, and guidance in brand settings.
  </Accordion>

  <Accordion title="A logo or color is wrong" icon="palette">
    Open **All brand settings** → **Visual Identity** and replace it. Your saved choice becomes the source Migma uses.
  </Accordion>

  <Accordion title="The writing does not sound right" icon="message-lines">
    Add a short example and clear direction under **Brand Guidelines** or **AI Instructions**. Specific examples work better than broad words like “professional.”
  </Accordion>
</AccordionGroup>

## Next

Choose a guide to continue.

<CardGroup>
  <Card title="Make your first email" icon="envelope-open-text" href="/get-started/create-first-email">
    Ask Migma for a draft, review it, and send a test.
  </Card>

  <Card title="How Migma works" icon="route" href="/get-started/setup-wizard">
    See the full path from brand to finished email.
  </Card>
</CardGroup>


# Create Your First Email with Migma
Source: https://docs.migma.ai/get-started/create-first-email

Create your first on-brand email in Migma from a plain-language brief, review the draft, request changes, run preflight checks, and send a test.

Tell Migma what you need in plain language. It uses the selected brand to prepare an editable draft.

<Frame>
  <img alt="Illustration showing a plain-language email request in Migma" />
</Frame>

## Make a draft

<Steps>
  <Step title="Open Create">
    Go to [Create](https://migma.ai/create) and choose the brand you want to use.
  </Step>

  <Step title="Ask for the email">
    Say what the email is for, who should receive it, and what action matters most.

    ```text theme={null}
    Create a launch email for our new pricing page.
    Keep it friendly, explain the main change, and use one clear button.
    ```
  </Step>

  <Step title="Review the draft">
    Migma opens the email on the canvas. Check the message, layout, images, links, and brand details.
  </Step>

  <Step title="Ask for changes">
    Use chat for changes such as “Make the opening shorter” or “Use the product image from our brand library.” Use the Visual Editor when you want to change text or layout directly.
  </Step>

  <Step title="Check and test">
    Run **Email Preflight**, then choose **Send Test Email**. You choose when it goes to your audience.
  </Step>
</Steps>

<Frame>
  <img alt="Illustration showing four coordinated Migma onboarding emails beside the design conversation" />
</Frame>

## Better requests need little detail

Include what is known. Migma can help fill gaps.

* **Purpose:** launch, newsletter, welcome, offer, update, receipt, or another clear job.
* **Reader:** new subscribers, customers, trial users, members, or another known audience.
* **Main action:** read, buy, book, reply, sign in, update details, or learn more.

## Start from something you already have

<CardGroup>
  <Card title="Figma" icon="figma" href="/creating-emails/figma-import">
    Turn a Figma email design into an editable email.
  </Card>

  <Card title="Screenshot" icon="camera" href="/creating-emails/image-clone">
    Use an image as visual direction, then make the result yours.
  </Card>

  <Card title="HTML" icon="code" href="/creating-emails/html-import">
    Bring an existing email into Migma and keep editing it.
  </Card>

  <Card title="Claude design" icon="wand-magic-sparkles" href="/creating-emails/claude-design">
    Bring in an email design made with Claude.
  </Card>
</CardGroup>

## Work with another AI tool

Connect Migma to Claude, ChatGPT, Codex, or another supported tool when you want to plan or create email there and keep Migma as the email workspace.

<CardGroup>
  <Card title="Connect Claude" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/tutorials/connect-migma-to-claude-code">
    Add Migma to Claude Code or Claude Desktop.
  </Card>

  <Card title="Connect ChatGPT" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/tutorials/connect-migma-to-chatgpt">
    Ask ChatGPT for email work while Migma keeps the canvas and sending controls.
  </Card>

  <Card title="See all integrations" icon="plug" href="/integrations/overview">
    Connect design, AI, business, sending, and automation tools.
  </Card>
</CardGroup>

## Next

Choose a guide to continue.

<CardGroup>
  <Card title="Check your email" icon="check-double" href="/email-editor/email-preflight">
    Preview real inboxes and catch issues before sending.
  </Card>

  <Card title="Send or export" icon="paper-plane" href="/email-editor/export-options">
    Choose Migma, your email service, or HTML.
  </Card>
</CardGroup>


# Get Started with Migma
Source: https://docs.migma.ai/get-started/introduction

Learn how Migma turns one brief into on-brand email campaigns you can edit, review, preflight, test, export, schedule, or send when ready.

<Frame>
  <img alt="Illustration of four coordinated Migma emails shown together on the visual canvas" />
</Frame>

Migma is your AI email marketer. Tell it the result you need. It prepares the copy, design, images, and email-safe build, then waits for your review.

## Why teams use Migma

* **Create the whole series:** prepare one email or a connected welcome, launch, onboarding, or re-engagement journey.
* **Stay on brand:** reuse your logo, colors, fonts, products, voice, references, and approved facts.
* **Review visually:** compare every email on one canvas. Edit through chat, Mark Select, or the Visual Editor.
* **Send with confidence:** check Outlook, Gmail, mobile, light mode, dark mode, links, and common sending problems first.

You choose when to test, export, schedule, or send.

## Choose your path

<CardGroup>
  <Card title="See how Migma works" icon="route" href="/get-started/setup-wizard">
    Follow the full path from brief to reviewed email.
  </Card>

  <Card title="Make your first email" icon="envelope-open-text" href="/get-started/create-first-email">
    Create a draft, make changes, and send yourself a test.
  </Card>

  <Card title="Use Claude" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/tutorials/connect-migma-to-claude-code">
    Connect Claude Code or Claude Desktop to Migma.
  </Card>

  <Card title="Use ChatGPT" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/tutorials/connect-migma-to-chatgpt">
    Connect the Migma plugin and work with `@Migma`.
  </Card>

  <Card title="Connect your tools" icon="puzzle-piece" href="/integrations/overview">
    Start from designs and business context, then send through Migma or your email platform.
  </Card>

  <Card title="Check inbox compatibility" icon="mobile" href="/email-editor/client-compatibility">
    See how one email stays readable across major inboxes and display modes.
  </Card>
</CardGroup>

You can also [use Migma from Grok Bot](/grok). Connect your account, verify your brand, and request an editable email draft to review.

<Warning>
  Email people who asked to hear from you. Cold email is not allowed. Read [what you can send](/get-started/what-you-can-send).
</Warning>


# Complete Migma Onboarding
Source: https://docs.migma.ai/get-started/onboarding-flow

Migma's onboarding takes you from a fresh signup to your first AI-generated, on-brand email in four steps. Plan on about 5–10 minutes end to end.

## Overview

Migma's onboarding takes you from a fresh signup to your first AI-generated, on-brand email in four steps. Plan on about 5–10 minutes end to end.

<Steps>
  <Step title="Sign up at migma.ai">
    Create your account.
  </Step>

  <Step title="Import a brand">
    Pull your logo, colors, and fonts from your website.
  </Step>

  <Step title="Set up your brand guidelines">
    Connect past emails so the AI learns your voice and style.
  </Step>

  <Step title="Generate your first email">
    Describe what you want and let Migma draft it on brand.
  </Step>
</Steps>

***

## Step 1 — Sign up at migma.ai

Head to [migma.ai](https://migma.ai) and create an account.

<Steps>
  <Step title="Visit migma.ai">
    Click **Get started** in the top-right of [migma.ai](https://migma.ai).

    <img alt="Sign in or Get started buttons on the Migma homepage" />
  </Step>

  <Step title="Sign up with email, Google, or SSO">
    Continue with Google for the fastest path, or use email + password.

    <img alt="Migma sign-in screen with Continue with Google and email options" />
  </Step>

  <Step title="Verify your account">
    Once you're in, your profile appears in the top-right with your plan and usage.

    <img alt="Migma account menu showing user, plan, and usage limits" />
  </Step>
</Steps>

***

## Step 2 — Import a brand

Migma auto-extracts your visual identity from your website so every email looks on brand from the first draft.

<Steps>
  <Step title="Open the brand panel">
    From the sidebar, open **My Brands** and click **+ New Brand**.

    <img alt="Migma sidebar with New Brand option" />
  </Step>

  <Step title="Enter your website URL">
    Paste your homepage URL — Migma auto-imports your logos, images, colors, and fonts.

    <img alt="Import your brand modal with website URL field" />
  </Step>

  <Step title="Review colors & styling">
    Inspect the extracted color themes and tweak roundness, typography, and other styling.

    <img alt="Colors and Styling page showing extracted brand themes" />
  </Step>

  <Step title="Confirm logos and save">
    Verify your primary logo, secondary logo, and favicon look right, then save your Brand Kit.

    <img alt="Brand Logos page with Primary Logo, Secondary Logo, and Favicon" />
  </Step>
</Steps>

<Tip>
  Want to fine-tune later? See [Configure brand](/get-started/configure-brand) for the full Brand Kit reference.
</Tip>

***

## Step 3 — Set up your brand guidelines

Brand guidelines are how Migma learns about you — your past emails, product details, and reference material. Feeding it gives the AI context so generated emails match your existing voice instead of sounding generic.

<Steps>
  <Step title="Open Brand Guidelines">
    Under **Content**, open **Brand Guidelines** to add reference material. Tone-of-voice instructions live in the separate **AI Instructions** section.

    <img alt="Brand Guidelines panel with Add Content button" />
  </Step>

  <Step title="Add an entry">
    Click **Add Content** and paste a past email, brief, or any reference. Plain text, HTML, and Markdown all work — or drop a file.

    <img alt="New Entry modal with title and content fields for a welcome email" />
  </Step>

  <Step title="Build up your library">
    Repeat for a handful of representative emails and notes. The richer the library, the closer your first generated draft will be to your usual style.

    <img alt="Brand Guidelines list showing a saved Welcome Email Template entry" />
  </Step>
</Steps>

<Note>
  The more representative content you add, the closer the first draft will be to your usual style.
</Note>

***

## Step 4 — Generate your first email

With your brand and guidelines in place, you're ready to create.

<Steps>
  <Step title="Start a new email">
    From the sidebar, click **New Email**.

    <img alt="Migma sidebar with New Email highlighted" />
  </Step>

  <Step title="Describe what you want">
    Prompt naturally — e.g. *"Launch announcement for our new pricing page, friendly tone, single CTA."* You can also clone a screenshot or import from Figma/HTML.

    <img alt="Create Emails Worth Opening prompt input with a launch announcement" />
  </Step>

  <Step title="Review and refine">
    Migma drafts using your Brand Kit and Brand Guidelines. Iterate inline until it's ready to send.

    <img alt="Generated on-brand pricing announcement email in the Migma editor" />
  </Step>
</Steps>

<Card title="Create your first email →" icon="wand-magic-sparkles" href="/get-started/create-first-email">
  Full walkthrough of prompt-based creation
</Card>

***

## What's next

<CardGroup>
  <Card title="Configure brand" icon="palette" href="/get-started/configure-brand">
    Fine-tune your Brand Kit
  </Card>

  <Card title="Setup wizard" icon="hat-wizard" href="/get-started/setup-wizard">
    Explore everything Migma can do
  </Card>

  <Card title="Send a campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Launch your first email to an audience
  </Card>

  <Card title="Billing & plans" icon="credit-card" href="/get-started/billing-and-plans">
    Pick a plan that fits
  </Card>
</CardGroup>

<Tip>
  Stuck during onboarding? Reach out via the in-app chat or browse the [FAQ](/faq).
</Tip>


# How Migma Works
Source: https://docs.migma.ai/get-started/setup-wizard

See how Migma turns a goal into one email or a complete series, keeps the work on brand, prepares it for real inboxes, and waits for your approval.

<Frame>
  <img alt="Illustration of four coordinated Migma emails shown together on the visual canvas" />
</Frame>

Migma turns a goal into one email or a full series. It uses your brand and approved facts, writes and designs the work, then puts every draft on one canvas for review.

You choose when to test, schedule, or send.

## What Migma does for you

* **Build the whole series:** ask once for a launch, welcome flow, newsletter, or lifecycle series. Migma plans emails that work together.
* **Keep it true to your brand:** reuse your logo, colors, fonts, products, voice, saved references, and approved facts.
* **Prepare it for real inboxes:** review Outlook, Gmail, Apple Mail, mobile, light mode, dark mode, links, and common sending problems.
* **Keep you in control:** change anything in chat or on the email. Send, schedule, or export only when you choose.

## From idea to finished email

<Steps>
  <Step title="Tell Migma the goal">
    Say who the email is for, what should happen next, and which facts matter. Ask inside Migma, Claude, or ChatGPT.
  </Step>

  <Step title="Review the campaign together">
    Migma places every email on the canvas. Read the full journey, compare drafts, and see how each message supports the next.
  </Step>

  <Step title="Make it yours">
    Ask for changes in chat, mark part of an email on the canvas, or open the **Visual Editor** for direct control over text, images, colors, spacing, links, and sections.
  </Step>

  <Step title="Check real inboxes">
    Run **Email Preflight** and send yourself a test. Fix anything important before your audience sees it.
  </Step>

  <Step title="Choose where it goes">
    Open **Publish**. Send with Migma, export to your email platform, or use the API. Live sending still needs your explicit action or approval.
  </Step>
</Steps>

## Work where you prefer

<CardGroup>
  <Card title="Migma" icon="wand-magic-sparkles" href="/get-started/create-first-email">
    Create, compare, edit, test, and publish from the visual canvas.
  </Card>

  <Card title="Claude" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/tutorials/connect-migma-to-claude-code">
    Plan and request email work in Claude, then open the result in Migma.
  </Card>

  <Card title="ChatGPT" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/tutorials/connect-migma-to-chatgpt">
    Ask from ChatGPT while Migma keeps brand, canvas, inbox, audience, and sending controls.
  </Card>

  <Card title="Your current tools" icon="puzzle-piece" href="/integrations/overview">
    Start from Figma, HTML, screenshots, and business context. Send through Migma or your email platform.
  </Card>
</CardGroup>

<Warning>
  Email people who asked to hear from you. Cold email is not allowed. Read [what you can send](/get-started/what-you-can-send).
</Warning>

## Next

Choose a guide to continue.

<CardGroup>
  <Card title="Make your first email" icon="envelope-open-text" href="/get-started/create-first-email">
    Follow one complete example from idea to inbox test.
  </Card>

  <Card title="See integrations" icon="puzzle-piece" href="/integrations/overview">
    Choose where work starts, what context helps, and where the result goes.
  </Card>

  <Card title="Check inbox compatibility" icon="mobile" href="/email-editor/client-compatibility">
    See how Migma prepares email for Outlook, Gmail, mobile, light mode, and dark mode.
  </Card>
</CardGroup>


# Tips to Get the Most Out of Migma
Source: https://docs.migma.ai/get-started/tips

Go to your brand settings and add your best-performing emails under Brand Guidelines. Migma learns your style, layout patterns, and what works for your audience.

<iframe title="Migma Tutorial" />

***

## Already have emails? Feed them to Migma.

Go to your brand settings and add your best-performing emails under **Brand Guidelines**. Migma learns your style, layout patterns, and what works for your audience. The more context you give, the better your output.

<Tip>
  Even 3-5 past emails make a noticeable difference in quality.
</Tip>

***

## Import your brand before anything else.

Paste your website URL. Migma pulls your logo, colors, fonts, and voice in seconds. Skip this and every email will need manual fixes. Do this once and never think about it again.

***

## Don't write the perfect prompt. Iterate.

Your first prompt doesn't need to be perfect. Generate something, then use chat to refine:

* *"Make the headline shorter"*
* *"Swap the CTA to green"*
* *"Add a testimonial section"*

It's a conversation, not a one-shot.

***

## Upload screenshots of emails you love.

See a competitor email or design you like? Screenshot it, drop it in Migma. It'll recreate it with **your** brand. Fastest way to get a great starting point.

***

## Be specific about what you want.

Bad: *"Create a sale email"*

Good: *"Create a summer sale email with 30% off, urgency-driven headline, hero image, 3 product cards, and a bold CTA"*

More detail = less back-and-forth.

***

## Use the visual editor for final tweaks.

AI gets you 90% there. The visual editor handles the last 10% — drag sections, adjust spacing, swap images. Don't fight the AI for pixel-level changes.

***

## Always run Preflight before sending.

One click shows you how your email looks on 30+ real devices. Catches broken layouts, missing images, and dark mode issues before your subscribers do.

***

## Connect your tools.

Already using Klaviyo, Mailchimp, or Shopify? Connect them. Pull products directly, export campaigns in one click, keep everything in sync.

<CardGroup>
  <Card title="Klaviyo" icon="k" href="/integrations/klaviyo">
    Export directly
  </Card>

  <Card title="Mailchimp" icon="envelope" href="/integrations/mailchimp">
    Push campaigns
  </Card>

  <Card title="Shopify" icon="cart-shopping" href="/integrations/shopify">
    Pull products
  </Card>
</CardGroup>

***

## Stuck? Ask the chat.

Migma's chat isn't just for generating emails. Ask it anything:

* *"What subject line would work best for this?"*
* *"How can I improve my open rate?"*
* *"Rewrite this for a younger audience"*

***

<Card title="Create your first email" icon="rocket" href="/get-started/create-first-email">
  Ready? Start creating.
</Card>


# What is Migma?
Source: https://docs.migma.ai/get-started/what-is-migma

Learn how Migma creates on-brand email campaigns and series, keeps every draft editable, checks real inboxes, localizes content, and waits for review.

Migma is your AI email marketer. Give it a goal, your brand, or an existing design. It prepares one email or a complete series, then waits for your review.

<Frame>
  <img alt="Illustration of four coordinated Migma emails shown together on the visual canvas" />
</Frame>

## Complete emails, not flat pictures

Migma keeps copy, buttons, links, and layout live and editable. Images support the design instead of replacing the whole email.

Each email is prepared as email-safe HTML for Outlook, Gmail, Apple Mail, Yahoo, mobile, light mode, and dark mode. [Email Preflight](/email-editor/email-preflight) checks inbox previews, links, wording, and common sending problems before anyone receives it.

* **One email or a full series:** ask for a welcome flow, launch, newsletter, onboarding series, win-back campaign, or transactional email. [See email series](/creating-emails/email-series).
* **Designed around your goal:** Migma plans the message, structure, images, and calls to action around what the reader should understand or do next.
* **Built from your brand:** reuse your logo, colors, fonts, products, voice, approved facts, and standing instructions. [Set up your brand](/get-started/configure-brand).
* **Easy to change:** edit through chat, mark one exact area on the canvas, or change text, images, buttons, colors, spacing, links, and sections directly. [Use the Visual Editor](/email-editor/visual-editor).

## Start with almost anything

Describe what you need, or bring work you already have. Migma can start from a Figma frame, screenshot, HTML email, Claude design, video, past email, or saved reference.

Favorite an email or save a design reference when you want Migma to use it again. Your current request still decides what the new email should become.

<CardGroup>
  <Card title="Describe the email" icon="message" href="/creating-emails/prompt-based-creation">
    Say what you are sending, who it is for, and what should happen next.
  </Card>

  <Card title="Bring in a design" icon="arrow-down-to-square" href="/creating-emails/overview">
    Use Figma, a screenshot, HTML, Claude design, or video as your starting point.
  </Card>

  <Card title="Use inspiration" icon="bookmark" href="/creating-emails/competitor-tracking">
    Browse saved work and competitor emails, add references to the canvas, then remix them for your brand.
  </Card>
</CardGroup>

## Review everything together

Migma puts every email in a series on one visual canvas. Your team can compare the full journey, comment, make changes, and work together in real time.

<Frame>
  <img alt="Illustration of four coordinated Migma emails reviewed together on the visual canvas" />
</Frame>

## Prepare every version your audience needs

Use one campaign to deliver supported language versions based on each contact's language. Migma keeps the design and message consistent while the language changes.

Before sending, preview the email across major inboxes and display modes. Send yourself a test when you want to check the real result.

<Frame>
  <img alt="Illustration of the same Migma email in Outlook, Gmail, Apple Mail, mobile, and dark mode with Preflight checks complete" />
</Frame>

<CardGroup>
  <Card title="Language versions" icon="language" href="/audience/multi-language">
    Prepare supported translations and send each contact the right version.
  </Card>

  <Card title="Inbox checks" icon="shield-check" href="/email-editor/client-compatibility">
    Review Outlook, Gmail, Apple Mail, mobile, light mode, and dark mode before sending.
  </Card>
</CardGroup>

## Work from Migma or your AI assistant

Create and review in Migma, or connect Claude, ChatGPT, Grok, Slack, Telegram, Codex, Cursor, and other supported AI clients. They use approved Migma access for brands, drafts, opted-in audiences, campaigns, and results.

<CardGroup>
  <Card title="Claude" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/tutorials/connect-migma-to-claude-code">
    Prepare email work from Claude Code, Claude Desktop, or Claude.ai, then review the result in Migma.
  </Card>

  <Card title="ChatGPT" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/tutorials/connect-migma-to-chatgpt">
    Use the Migma plugin in ChatGPT, approve access, and open completed drafts in Migma.
  </Card>

  <Card title="Grok and other agents" icon="microchip" href="/agents/overview">
    Connect through Migma's agent tools, approve access, and keep one reviewed email workflow.
  </Card>

  <Card title="Slack and Telegram" icon="message" href="/integrations/overview">
    Ask for branded drafts from chat, then open Migma to review, export, or send.
  </Card>
</CardGroup>

<Note>
  Connecting an agent does not give it unlimited control. You review requested access, and sending requires send-capable permission.
</Note>

## Keep your current tools

Migma can use product and business context from connected tools while writing. When the email is ready, send with Migma or hand it to your existing platform.

<Frame>
  <img alt="Illustration of Migma connected to design sources, business context, chat tools, and email platforms" />
</Frame>

<CardGroup>
  <Card title="Use business context" icon="database" href="/integrations/overview">
    Use connected Shopify, Stripe, and external tools while preparing the email.
  </Card>

  <Card title="Export to your platform" icon="file-export" href="/email-editor/export-options">
    Hand reviewed work to Mailchimp, Klaviyo, Brevo, Omnisend, or an existing HubSpot connection.
  </Card>

  <Card title="Send from Migma" icon="paper-plane" href="/campaigns/send-campaign">
    Choose an audience, sender, schedule, and tracking options, then approve the send.
  </Card>

  <Card title="See what happened" icon="chart-line" href="/campaigns/track-results">
    Review delivery, opens, clicks, recipient activity, and Click map results for Migma sends.
  </Card>
</CardGroup>

## Plan, audience, and sending

* **Marketing Calendar:** review suggested moments and emails Migma prepared for upcoming events. You approve each one before it is scheduled.
* **Audience:** import opted-in contacts from Mailchimp, Klaviyo, HubSpot, or CSV. Build changing segments from plain English, such as "customers in Spain with an active plan."
* **Sending Domains:** start with a Migma address for tests and small sends, connect a domain you own for production, or buy a domain in Migma.

<CardGroup>
  <Card title="Plan email" icon="calendar" href="/campaigns/marketing-calendar">
    Review upcoming moments and prepared drafts.
  </Card>

  <Card title="Manage your audience" icon="users" href="/audience/overview">
    Import contacts, organize lists, and build dynamic segments.
  </Card>

  <Card title="Set up sending" icon="globe" href="/sending-domains/overview">
    Choose the right sender for testing or production.
  </Card>
</CardGroup>

<Warning>
  You decide when to test, export, change an audience, schedule, or send. Email only people who asked to hear from you. [Cold email is not allowed](/get-started/what-you-can-send).
</Warning>

## Start using Migma

Choose a guide to continue.

<CardGroup>
  <Card title="How Migma works" icon="route" href="/get-started/setup-wizard">
    Follow the path from brand and brief to reviewed email.
  </Card>

  <Card title="Make your first email" icon="envelope-open-text" href="/get-started/create-first-email">
    Create a draft, make changes, and send yourself a test.
  </Card>
</CardGroup>


# What Emails Can You Send with Migma?
Source: https://docs.migma.ai/get-started/what-you-can-send

Learn which permission-based marketing and transactional emails you can send with Migma, which contacts to exclude, and how sending safeguards work.

Migma is for email people asked for or reasonably expect from your brand.

<Frame>
  <img alt="Illustration comparing contacts who can receive email with contacts who did not give permission" />
</Frame>

<Info>
  Migma is not for cold email. Do not use scraped, bought, rented, borrowed, or guessed email addresses.
</Info>

## Good uses

<CardGroup>
  <Card title="Marketing people chose" icon="newspaper">
    Newsletters, product news, offers, event updates, welcome flows, and other marketing for subscribers who opted in.
  </Card>

  <Card title="Messages people need" icon="receipt">
    Account, order, billing, security, and service updates connected to an action or customer relationship.
  </Card>
</CardGroup>

## Quick permission check

<Card title="Did this person choose to hear from us?" icon="circle-check">
  A clear newsletter form, checkout choice, account setting, or request for updates counts. Being in a CRM, attending a call, matching your audience, or appearing on LinkedIn does not.
</Card>

## Before sending marketing email

<Check>Each person has clear permission to receive this kind of email.</Check>
<Check>Your list keeps the original subscription status when moved from another service.</Check>
<Check>Unsubscribed, bounced, invalid, and blocked contacts stay out.</Check>
<Check>Your email includes an easy way to unsubscribe or change preferences.</Check>

<Note>
  Account and order messages are different from marketing. Send them only when they are needed, and still keep bounced, complained, or manually blocked addresses out.
</Note>

## How Migma helps

<CardGroup>
  <Card title="Audience controls" icon="users" href="/audience/overview">
    Keep subscription status, preferences, and contact details together.
  </Card>

  <Card title="Suppression list" icon="ban" href="/sending-domains/suppression-list">
    Prevent unsubscribed, bounced, complained, or blocked contacts from receiving mail.
  </Card>

  <Card title="Email Preflight" icon="check-double" href="/email-editor/email-preflight">
    Review links, wording, spam risk, and inbox rendering before sending.
  </Card>

  <Card title="Sending domain" icon="globe" href="/sending-domains/overview">
    Send larger campaigns from an address that belongs to your brand.
  </Card>
</CardGroup>

<Tip>
  Use **Send Test Email** while reviewing a draft. Tests work without adding a sending domain and do not send to your audience.
</Tip>

## Learn more

<CardGroup>
  <Card title="Add contacts from a file" icon="file-csv" href="/audience/csv-upload">
    Bring in people while preserving who can receive marketing.
  </Card>

  <Card title="GDPR newsletter consent" icon="shield-check" href="/compliance/gdpr-newsletter-consent">
    Set up clear newsletter permission for EU and UK subscribers.
  </Card>

  <Card title="CAN-SPAM checklist" icon="clipboard-check" href="/compliance/can-spam-checklist">
    Review sender details, content, and unsubscribe requirements.
  </Card>

  <Card title="Audience health" icon="heart-pulse" href="/audience/deliverability">
    Keep your list clean and protect future delivery.
  </Card>
</CardGroup>


# Connect Migma to Grok Bot
Source: https://docs.migma.ai/grok

Connect Migma to Grok Bot, verify your brand, and create your first editable email draft before preparing an approved campaign.

Connect Migma to Grok Bot to create editable emails using your saved brand, review previews, prepare campaigns for opted-in subscribers, and read results. Start with one draft. Creating an email does not send it.

This guide covers the **Grok Bot desktop app**. You need a Migma account, access to your brand, and permission to add connections in Grok Bot.

## Quick start

1. Paste the setup prompt below into Grok Bot and approve the connection in your browser.
2. Ask Grok Bot to find your brand read-only. Confirm that the returned brand is yours.
3. Request one editable email draft. Open its preview and Migma canvas link before continuing.

For first-email prompts, read [Grok Bot email marketing: setup and first draft](https://migma.ai/blog/ai-email-marketing-from-grok-bot). For audience, sender, review, and results, use [Grok Bot email campaigns: from brief to results](https://migma.ai/blog/design-send-marketing-emails-grok-bot).

Grok Bot connects through Migma Remote MCP, which lets it use Migma tools, at `https://migma.ai/mcp`. Sign-in and access approval happen in your browser.

<Info>
  Agent-guided Remote MCP setup is available in Grok Bot desktop with user approval. Marketplace availability and connector authentication vary by Grok build and workspace policy.
</Info>

<Warning>
  Use one write path per task. Finish or pause current work before switching between Migma MCP and browser operation. This prevents duplicate drafts.
</Warning>

## Start email marketing with Grok Bot

Copy this prompt into Grok Bot:

```text theme={null}
Set up Migma so you can run my email marketing.
Read https://docs.migma.ai/grok.md and reuse my existing Migma connection if available.
Ask before adding a connection. I'll review access in my browser.
Then find my brand [brand name] with a read-only request and report which tool succeeded.
Do not create, import, schedule, or send anything during setup.
```

<Frame>
  <img alt="Illustration showing Migma connected to Grok Bot through the Migma Remote MCP URL" />
</Frame>

## Before you start

You need:

* A Migma account.
* Grok Bot desktop with plugins and MCP connections allowed.
* A browser for Migma access approval.

Team and Enterprise admins may need to allow the Migma server URL before members can connect it. Grok Bot follows the same plugin and MCP policy as Cursor.

## Connect Migma from Grok Bot

<Steps>
  <Step title="Ask Grok Bot to add Migma">
    Check **Plugins → Your plugins** for an existing Migma connection first. If it needs authentication, select **Authenticate** and complete the access approval. If no connection exists, create a Bot and paste the prompt above to add Migma.

    Grok Bot should discover `https://migma.ai/mcp` and ask before adding it. Choose the approval action only when the endpoint is exact.

    <Frame>
      <img alt="Illustration showing Grok Bot reading Migma setup guidance, finding the Migma Remote MCP URL, and asking whether to add the connector" />
    </Frame>
  </Step>

  <Step title="Review Migma access">
    Follow the installed connector's browser approval. Sign in if needed, review the app and permissions, then select **Allow** when they match your intended access. Return to Grok Bot and check the connector status.

    Full access lets Grok Bot design, import audiences, and send for you. Review those permissions before approval. Require confirmation for each send in the chat and keep Grok Bot's approval controls enabled.

    <Frame>
      <img alt="Illustration showing the Migma connection review with app, return destination, requested access, Cancel, and Allow" />
    </Frame>

    Migma creates the connection credential after your approval and hands it to Grok Bot directly.
  </Step>

  <Step title="See your account">
    A **Connected** badge is the first check. Ask Grok Bot to make a read-only request for the brand you want to use:

    ```text theme={null}
    Use Migma to find my brand [brand name] read-only.
    State which Migma tool succeeded. Do not create or send anything yet.
    ```

    <Frame>
      <img alt="Illustration showing Grok Bot calling Migma list projects, returning a sanitized demo brand, and making no changes" />
    </Frame>
  </Step>
</Steps>

### How Grok Bot connects

Use the installed Migma connector's browser authentication first. In a September 4, 2026 check, selecting **Authenticate** restored an existing connector to **Connected**, and Grok Bot successfully read a Migma brand through its tools. This verifies that connection, not every Grok build or workspace policy.

If a direct agent cannot complete browser OAuth, it may use the conditional claim-code flow described in [Agent registration](/agent-registration). That requires secure credential storage and does not repair a hosted connector that still reports `needsAuth`.

## Create your first email draft

After the read-only request succeeds, replace the brackets and send:

```text theme={null}
Use Migma with brand [brand name].
Create one welcome email for people who signed up on our website.
Goal: help them [first useful action].
Use our saved brand style and only these approved facts: [facts].
Main link: [destination URL].
Keep it as an editable draft. Show the preview and Migma canvas link.
Do not create a campaign, import contacts, schedule, or send.
```

Open the returned email and check the facts, branding, images, and links. For a focused change, identify that email by its canvas link and name the section to edit. Review the new preview before preparing recipients or delivery.

Use [Email Preflight](/email-editor/email-preflight) to check the finished email. A test email is a separate send that requires your approval; it uses Migma's sender and does not verify your own campaign sender.

<Note>
  Our September 4, 2026 Grok Bot check verified authentication and reading a saved brand. Draft generation reached the account's daily limit, so that run did not verify a generated preview, edit, or received test. The workflow below describes documented Migma capabilities.
</Note>

## Other Grok clients

Grok web and Grok Build are separate from Grok Bot desktop.

For Grok web, open [grok.com/connectors](https://grok.com/connectors), choose **New Connector → Custom**, and add `https://migma.ai/mcp`.

For Grok Build:

```bash theme={null}
grok mcp add --transport http migma https://migma.ai/mcp
grok mcp doctor migma
```

## Browser fallback

When you choose browser fallback, Grok Bot may operate a signed-in Migma browser session. Take over for password, passkey, two-factor code, and CAPTCHA. Every Bot shares that cloud computer and its browser sessions. Sign out after use.

## Give Grok Bot its job

Ask Grok Bot to read this page, then save this operating instruction:

```text theme={null}
You run my communication through Migma: launches, announcements, newsletters, campaigns.
Write like we're chatting on WhatsApp: 1–2 short sentences, simple words, result and useful links. No fluff, hype, long recaps, or automatic follow-up offers. Match my language. Give more detail only when I ask or need to make a decision.
Start each session with migma_get_context and use the setup block to handle my task. Keep the checklist internal; ask one short question only when needed.
Raise missing setup only when it helps my current task. Handle one thing at a time; don't turn the conversation into a setup checklist.
Create drafts and show me every preview and canvas link.
When I like a Migma email's design or say "save this style," call migma_save_reference with that exact emailId. For a series, save only the email I chose. Confirm after favorite:true.
For an external email, save projectId + title + html. A screenshot alone can guide generation through images, but cannot be saved as a standing reference.
Build on facts from my brand or facts I give you, and send only to people who opted in.
Before any send or schedule, show me the audience, recipient count, sender, subject, and final preview, then wait for my yes in this chat.
```

## Run the email marketing loop

Migma MCP returns exact brand, email, campaign, audience, and result data. Use Migma tools as the active write path for this workflow.

<Steps>
  <Step title="Choose one brand">
    Ask Grok Bot to list Migma brands, then select one.
  </Step>

  <Step title="Save lasting brand facts">
    When you share tone, offers, product facts, policies, or FAQs that should persist, ask Migma to save them to the selected brand's knowledge base.
  </Step>

  <Step title="Build a source brief">
    For current launches or product news, make Grok research primary sources first. Require a dated checklist of exact facts for each email and up to five public HTTPS source-image URLs. Use primary sources for facts and images for visual direction.
  </Step>

  <Step title="Create drafts first">
    Ask for one email or a short series. State audience, goal, approved facts, and CTA. End with **Keep these as editable drafts and show every preview.**

    ```text theme={null}
    Use Migma with brand [name].
    Create 3 launch emails for [audience].
    Goal: [action].
    Required facts by email: [exact checklist from verified sources].
    Source images: [up to 5 public HTTPS URLs].
    Pass those URLs through migma_generate_email.images as structured image inputs.
    Keep every email as an editable Migma draft and show each preview.
    ```

    <Frame>
      <img alt="Illustration showing three Migma draft email previews in Grok Bot and confirmation that no email was sent" />
    </Frame>
  </Step>

  <Step title="Review and check">
    Review returned previews in Grok Bot. Check every required fact in content and every expected source asset in images before saying the work is complete. If a preview cannot be inspected, say verification is incomplete and open its Migma link. Ask for targeted text edits, then run compatibility and deliverability checks. Use replacement generation to add missing structured images.
  </Step>

  <Step title="Prepare the audience">
    Import only opted-in contacts, or choose an existing list or segment. Ask Grok Bot to report created, updated, skipped, and failed counts before continuing.
  </Step>

  <Step title="Confirm the sender">
    Ask Migma to list available sending domains and From addresses. If none are ready, set up a domain you own. A managed Migma address supports testing and small transactional sends, with a 50-email daily limit and a 50-recipient limit per send. Connect your own domain for larger campaigns.
  </Step>

  <Step title="Prepare the campaign for review">
    Ask Grok Bot to create the draft, then pause for review:

    ```text theme={null}
    Create a campaign draft from email [email id or canvas link].
    Recipients: [opted-in list or segment].
    Subject: [subject].
    Sender: [sender].
    Keep the campaign in draft. Show recipient count, sender, subject, and final preview, then wait for my approval.
    ```

    <Frame>
      <img alt="Illustration showing Grok Bot and Migma preparing a campaign summary with audience, sender, schedule, previews, and nothing sent" />
    </Frame>
  </Step>

  <Step title="Approve the exact send">
    Send or schedule only after audience, recipient count, sender, subject, timing, and preview match your intent. Keep Grok Bot approval controls enabled.
  </Step>

  <Step title="Read results and improve the next brief">
    After sending, ask Migma for campaign stats and delivery logs. Use clicks, bounces, and complaints to shape the next draft.

    <Frame>
      <img alt="Illustration showing Grok Bot using Migma campaign stats to summarize delivery, opens, clicks, bounces, and recommend the next brief" />
    </Frame>
  </Step>
</Steps>

## Prompts worth saving

### Save an email you like

```text theme={null}
I like this email's design: [Migma canvas link or emailId].
Save it as a reference for future emails for this brand.
```

Grok Bot calls `migma_save_reference` with the selected `emailId`. This favorites the email and makes its saved design available to future emails for the same brand by default, unless saved references are disabled. Later edits to the favorite update the reference too.

For a series, name the email you want to save. Grok Bot should use that email's ID, confirm only after `favorite: true`, and continue your task. Saving requires `project:write` and does not need an HTML export, a new draft, or sending permission. Repeating the same `emailId` keeps it favorited.

### Import an opted-in CSV

```text theme={null}
Use Migma with brand [name].
Import this CSV into a list named "[list name]".
These contacts opted in on our site.
Use one contact import with the full CSV text.
Report created, updated, skipped, and failed counts.
```

### Approve one exact send

```text theme={null}
Use campaign [name or id].
Confirm the audience, recipient count, sender, subject, final preview, date, time, and timezone.
Send when every value matches this conversation.
When any value differs, show the exact correction and wait for approval.
```

### Read performance

```text theme={null}
Use Migma to show stats and recent delivery logs for campaign [name or id].
Explain the strongest click signal, bounces, and complaints in plain language.
Recommend the next email brief and return the analysis only.
```

## Safe routines

After the Migma connection is verified, first run the task once. When the result is stable, save it as a Grok Bot skill or routine.

Good routines prepare work and stop:

```text theme={null}
Every Monday at 9:00 AM, review last week's Migma campaign results for brand [name].
Prepare one draft based on the strongest click signal.
Use only approved brand facts and opted-in audience data.
Show the preview and reasoning, then wait for approval.
```

Keep routines in preparation and review mode. xAI recommends approval for sending, publishing, deleting, purchasing, and production changes.

## Disconnect or revoke access

1. Pause any routine that uses Migma.
2. Open **Settings → Plugins**, find the installed Migma connector, and disconnect or remove it.
3. Revoke its matching OAuth-created key in **Migma Settings → Developers → API Keys**.
4. If you used claim-code, revoke the matching `Agent:` key and remove its stored credential from Grok.
5. If you used browser fallback, sign out of Migma inside **Grok Bot's Computer**.

## Troubleshooting

| Problem | Fix |
| - | - |
| Grok Bot cannot add Migma | Check **Settings → Plugins** and workspace MCP policy. An admin may need to allow `https://migma.ai/mcp`. |
| Migma keeps asking for login | Open **Plugins → Your plugins → Migma**, select **Authenticate**, and complete browser approval. Then repeat a read-only brand request. |
| Bot cannot find a brand | Confirm the approved Migma account can access that brand, then repeat the read-only brand request. |
| Bot starts changing data during setup | Send `Stop now`, then repeat the setup prompt above. |
| Bot keeps retrying a connector OAuth flow | Stop the retry loop and inspect the installed connector. Complete its authentication, then verify with a read-only brand request. If it still fails, report the exact error and Grok build. |
| A direct agent needs a connection credential | Follow the conditional fallback in [Agent registration](/agent-registration). The agent must support secure credential storage; approve access in your browser. |
| Duplicate drafts appear | Browser and MCP wrote at the same time. Stop both, list existing drafts read-only, keep one set, then continue through one mode. |
| Researched features or images are missing | Rebuild an exact fact checklist. Pass source URLs through structured `images`, regenerate once, then verify content and previews. |
| Generation reports a daily limit | Check your Migma plan and usage. Wait for the limit to reset or review an upgrade yourself, then retry once. A successful connection does not mean generation capacity remains. |

Current Grok behavior: [Grok Bot overview](https://docs.x.ai/grok-bot/overview), [get started and computer login](https://docs.x.ai/grok-bot/get-started), [skills and routines](https://docs.x.ai/grok-bot/skills-routines-and-automations), [approvals and security](https://docs.x.ai/grok-bot/approvals-security-and-privacy), and [Grok Build MCP](https://docs.x.ai/build/features/mcp-servers).

## Next

<CardGroup>
  <Card title="Grok Bot email campaign guide" icon="bullhorn" href="https://migma.ai/blog/design-send-marketing-emails-grok-bot">
    Turn a brief into reviewed emails, prepare recipients, and read campaign results.
  </Card>

  <Card title="Grok Bot email prompts" icon="pen-to-square" href="https://migma.ai/blog/ai-email-marketing-from-grok-bot">
    Start with welcome, newsletter, and product-launch drafts.
  </Card>

  <Card title="MCP permissions" icon="shield-check" href="/security/mcp">
    Review access, approval, and revocation before connecting.
  </Card>

  <Card title="Migma MCP server" icon="server" href="/mcp-server">
    See hosted MCP behavior and troubleshooting.
  </Card>
</CardGroup>


# Amazon SES Integration
Source: https://docs.migma.ai/integrations/amazon-ses

Connect Amazon SES as a Migma delivery provider, configure credentials and a verified sender, then test and send Migma-created email through AWS.

Use Amazon SES when your team already manages delivery through AWS or wants Migma-created emails delivered through SES.

## What SES does in Migma

<CardGroup>
  <Card title="Delivery provider" icon="paper-plane">
    Migma prepares and sends the email, while SES handles delivery.
  </Card>

  <Card title="Verified sender required" icon="shield-check">
    The from address must use a domain or sender setup approved for SES sending.
  </Card>

  <Card title="Campaign and API sends" icon="code-bracket">
    Use SES from Migma sends when that provider is selected.
  </Card>

  <Card title="Migma records stay connected" icon="chart-bar">
    Campaign, logs, and suppression behavior stay in Migma workflows where supported.
  </Card>
</CardGroup>

## Setup checklist

<Steps>
  <Step title="Prepare SES">
    Verify your sending identity in AWS and make sure the account is approved for the type of sending you plan to do.
  </Step>

  <Step title="Connect SES in Migma">
    Open **Settings** and connect Amazon SES under email providers.
  </Step>

  <Step title="Choose the provider">
    When sending from Migma or the API, choose SES as the delivery provider.
  </Step>

  <Step title="Send a test">
    Send to internal test recipients before approving a campaign.
  </Step>
</Steps>

<Info>
  If you do not already use AWS for email delivery, Migma sending is usually the fastest setup path.
</Info>

## Related docs

<CardGroup>
  <Card title="Email Service Providers" icon="envelope" href="/integrations/email-service-providers">
    Compare direct sending providers.
  </Card>

  <Card title="Sending Domains" icon="globe" href="/sending-domains/overview">
    Prepare sender identity and domain health.
  </Card>
</CardGroup>


# Brevo Integration
Source: https://docs.migma.ai/integrations/brevo

Connect Brevo to Migma, prepare and preflight an on-brand email, then export the template for lists, automations, campaign review, and sending in Brevo.

Use Brevo when Migma should prepare and preflight the email, then Brevo should own the final list, automation, or send.

## What you can do

<CardGroup>
  <Card title="Connect with an API key" icon="key">
    Add a Brevo API key for the brand that should export to Brevo.
  </Card>

  <Card title="Export templates" icon="document-plus">
    Push reviewed email HTML into Brevo templates.
  </Card>

  <Card title="Use verified senders" icon="shield-check">
    Choose Brevo sender details during export when required.
  </Card>

  <Card title="Finish in Brevo" icon="arrow-top-right-on-square">
    Review the exported template, then use Brevo for contacts, automation, or final sending.
  </Card>
</CardGroup>

## Connect Brevo

<Steps>
  <Step title="Open Publish or brand integrations">
    Choose **Brevo** from Publish, or open the brand's integration settings.
  </Step>

  <Step title="Add the API key">
    Paste a Brevo API key that can manage templates.
  </Step>

  <Step title="Confirm the connection">
    Migma checks the configuration before showing export actions.
  </Step>
</Steps>

<Warning>
  Keep Brevo API keys private. Only add keys from accounts that are approved for this brand's email work.
</Warning>

## Export to Brevo

<Steps>
  <Step title="Review the email in Migma">
    Check rendering, links, and content before export.
  </Step>

  <Step title="Choose Brevo in Publish">
    Enter the template name, subject, and sender details.
  </Step>

  <Step title="Create or update the template">
    Migma exports the email to Brevo.
  </Step>

  <Step title="Finish in Brevo">
    Use the template in a campaign, automation, or transactional flow in Brevo.
  </Step>
</Steps>

## Related docs

<CardGroup>
  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    See every export destination.
  </Card>

  <Card title="Migma vs Brevo" icon="scale-balanced" href="/comparisons/migma-vs-brevo">
    Compare the workflow split between Migma and Brevo.
  </Card>
</CardGroup>


# Email Service Providers
Source: https://docs.migma.ai/integrations/email-service-providers

Choose between Migma built-in sending and connected providers such as Amazon SES, Resend, SendGrid, or Mailgun for campaign and API delivery.

Migma can send email through built-in sending or through a connected delivery provider. Choose the provider that should deliver the message, then review campaign state, logs, and results from Migma where supported.

<Info>
  Mailchimp, Klaviyo, HubSpot, Omnisend, and Brevo are export destinations. They are separate from direct delivery providers. See [Platform Integrations](/integrations/platform-integrations).
</Info>

<Note>
  Migma sending has the most complete Migma-side tracking. Third-party delivery providers can expose less detail inside Migma depending on the provider setup.
</Note>

## Supported sending providers

| Provider | Best for | External account needed |
| - | - | - |
| [Migma sending](/sending-domains/overview) | Fastest setup, managed or custom domains, Migma campaign workflows | No |
| [Amazon SES](/integrations/amazon-ses) | Teams already using AWS email infrastructure | Yes |
| [Resend](/integrations/resend) | Developer-led lifecycle and transactional email | Yes |
| [SendGrid](/integrations/sendgrid) | Teams already using SendGrid delivery | Yes |
| [Mailgun](/integrations/mailgun) | Teams already using Mailgun delivery | Yes |

## How provider choice works

The sending domain or sender still needs to be approved for the provider you choose. If no external provider is selected, Migma uses built-in sending.

```typescript theme={null}
await migma.sending.send({
  recipientType: 'email',
  recipientEmail: 'sarah@example.com',
  from: 'hello@yourdomain.com',
  fromName: 'Your Brand',
  subject: 'Welcome!',
  emailId: 'email_123',
  providerType: 'resend'
});
```

Supported `providerType` values:

| Value | Provider |
| - | - |
| `migma` | Migma sending |
| `ses` | Amazon SES |
| `resend` | Resend |
| `sendgrid` | SendGrid |
| `mailgun` | Mailgun |

## Setup checklist

<Steps>
  <Step title="Verify sender identity">
    Set up a managed Migma address, a custom sending domain, or a provider-approved sender.
  </Step>

  <Step title="Connect the provider">
    Add provider credentials in **Settings** under email providers.
  </Step>

  <Step title="Choose the provider">
    Select the provider for campaign or API sends.
  </Step>

  <Step title="Send a test">
    Check sender, reply-to, rendering, tracking, and unsubscribe behavior before launch.
  </Step>

  <Step title="Monitor results">
    Review logs, bounces, complaints, skipped recipients, and domain health after sending.
  </Step>
</Steps>

## Choosing a provider

| If you need | Use |
| - | - |
| No external ESP setup | Migma sending |
| Existing AWS delivery setup | Amazon SES |
| Developer-first provider workflow | Resend |
| Existing SendGrid infrastructure | SendGrid |
| Existing Mailgun infrastructure | Mailgun |
| Mailchimp, Klaviyo, HubSpot, Omnisend, or Brevo campaign workflow | Export to that platform instead |

## Related pages

<CardGroup>
  <Card title="Sending Domains" icon="globe" href="/sending-domains/overview">
    Set up managed or custom sending domains.
  </Card>

  <Card title="Send Campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Send a campaign from Migma.
  </Card>

  <Card title="Email Logs" icon="list-bullet" href="/sending-domains/email-logs">
    Review individual email delivery status and tracking data.
  </Card>

  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Use export when another platform owns final sending.
  </Card>
</CardGroup>


# Figma Integration
Source: https://docs.migma.ai/integrations/figma

Connect Figma to Migma, import a prepared frame as editable email content, review inbox compatibility, and export approved work for handoff.

Use Figma when a design already exists and Migma should turn it into an editable, email-safe email. You can also export reviewed email work for Figma handoff when your team wants to keep design review in Figma.

Figma import works best for single email frames, landing-style announcement designs, and campaign modules that need to keep visual direction while becoming production email.

## What you can do

<CardGroup>
  <Card title="Import a frame" icon="arrow-down-tray">
    Paste a Figma frame URL and convert it into editable email.
  </Card>

  <Card title="Use private files" icon="lock-closed">
    Connect Figma so Migma can access files your account can view.
  </Card>

  <Card title="Review and edit" icon="pencil-square">
    Continue in chat, visual editor, or code view after import.
  </Card>

  <Card title="Export anywhere" icon="arrow-up-tray">
    Export the finished email to files, campaigns, Figma handoff, or connected platforms.
  </Card>
</CardGroup>

## Connect Figma

<Steps>
  <Step title="Open brand integrations">
    Open the brand you are working in, then open **Integrations**.
  </Step>

  <Step title="Connect Figma">
    Choose **Figma** and approve access. Migma stores the connection for that brand.
  </Step>

  <Step title="Paste a Figma URL">
    Copy the Figma frame URL and paste it on **Create** or into design chat.
  </Step>

  <Step title="Review the email">
    Check layout, images, links, mobile behavior, and preflight results before export or send.
  </Step>
</Steps>

<Info>
  For public or shareable Figma links, you can often paste the URL directly. Connect Figma when the file is private or your team imports from Figma often.
</Info>

## Export to Figma

From **Publish**, choose **Figma** when the reviewed email should move back into a design handoff flow. This is useful when designers want to inspect or adapt the final email structure after Migma prepares it.

<Note>
  Figma export is a design handoff path. For production delivery, use [export options](/email-editor/export-options), Migma sending, or a connected marketing platform.
</Note>

## Prepare the Figma file

For best conversion quality:

* Use one frame for one email.
* Keep the email width close to typical email dimensions.
* Use Auto Layout where possible.
* Use real images instead of screenshots of text.
* Name important sections clearly.
* Flatten complex icons or decorative vectors when they are not meant to be edited.

<Card title="Designing in Figma for Email" icon="ruler" href="/creating-emails/figma-design-guide">
  Set up a Figma file so Migma can convert it cleanly.
</Card>

## Related docs

<CardGroup>
  <Card title="Figma to Email" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/figma.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=1388542bde3d29ae9480addef82339cf" href="/creating-emails/figma-import">
    Step-by-step import workflow.
  </Card>

  <Card title="Client Compatibility" icon="check-circle" href="/email-editor/client-compatibility">
    How Migma renders imported designs for Outlook, webmail, and mobile.
  </Card>

  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Export the finished email after review.
  </Card>

  <Card title="Email Preflight" icon="shield-check" href="/email-editor/email-preflight">
    Check rendering, content, and deliverability before launch.
  </Card>
</CardGroup>


# HubSpot Integration
Source: https://docs.migma.ai/integrations/hubspot

Use HubSpot when your team wants Migma to prepare the email, then finish review, list selection, automation, or send inside HubSpot.

Use HubSpot when your team wants Migma to prepare the email, then finish review, list selection, automation, or send inside HubSpot.

## What you can do

<CardGroup>
  <Card title="Existing OAuth connection" icon="key">
    Existing HubSpot connections use OAuth. New HubSpot connections are not available.
  </Card>

  <Card title="Export reviewed email" icon="arrow-up-tray">
    Send HubSpot-ready HTML from Publish after reviewing the email in Migma.
  </Card>

  <Card title="Preserve HubL" icon="code-bracket">
    Keep HubSpot personalization syntax in the exported email.
  </Card>

  <Card title="Keep a Migma record" icon="clipboard-document-list">
    External campaign handoff is recorded in Migma when campaigns are exported or scheduled.
  </Card>
</CardGroup>

<Info>
  HubSpot export and contact import work for existing connections. New HubSpot connections are not available.
</Info>

## Export to HubSpot

<Steps>
  <Step title="Review the email in Migma">
    Check content, links, mobile rendering, and preflight before export.
  </Step>

  <Step title="Open Publish">
    Choose **HubSpot** from the export destinations.
  </Step>

  <Step title="Create the draft">
    Migma prepares HubSpot-compatible HTML and opens the HubSpot handoff when export succeeds.
  </Step>

  <Step title="Finish in HubSpot">
    Review the draft, choose final audience or automation settings, then send from HubSpot.
  </Step>
</Steps>

## Personalization

Migma preserves HubSpot syntax that you include in the email. Use HubL or contact tokens intentionally, and preview them with HubSpot data before sending.

```text theme={null}
Create a lifecycle email that greets {{ contact.firstname }} and mentions {{ company.name }}.
Use HubSpot HubL syntax.
```

## Import contacts from HubSpot

Bring a HubSpot contact list into Migma without exporting a CSV. Imports read from your connected HubSpot account and run in the background.

<Steps>
  <Step title="Start from Contacts">
    In **Audience**, click **Add Contact** then **Import from integration** and choose **HubSpot**. An existing HubSpot connection is required.
  </Step>

  <Step title="Choose a contact list">
    Pick the HubSpot list you want to import. Static lists appear as lists and smart lists appear as segments.
  </Step>

  <Step title="Confirm consent behavior">
    Migma shows which contacts can receive marketing email before the import starts. HubSpot imports are conservative by design, as explained below.
  </Step>

  <Step title="Start the import">
    The import runs as a background job. Watch progress in the dialog, or check **Import History** for the final counts.
  </Step>
</Steps>

### How Migma treats HubSpot consent

HubSpot is a CRM, and being on a CRM list is not the same as having permission to receive marketing email. Migma treats HubSpot imports conservatively:

* Contacts import as subscribed only when their HubSpot marketing email subscription data shows an explicit opt-in.
* Contacts who opted out of marketing email import as unsubscribed, for record keeping only.
* Everything else, including plain list membership, imports as non-sendable.

There is no manual override. If Migma cannot verify marketing permission from HubSpot data, the imported contacts stay non-sendable even when the selected list looks like a marketing audience. Existing Migma contacts that unsubscribed or bounced are never resubscribed by an import.

### Source tag and snapshot segment

Every import creates a source tag named after the list, such as `Newsletter Subscribers`, and a snapshot segment that targets it. Importing the same list again reuses the same tag and segment, and each import still gets its own **Import History** record showing the provider, account, source, consent mode, and how many contacts were imported, updated, kept non-sendable, skipped, or failed.

<Note>
  Imports are one-time snapshots. Migma copies the selected list at import time and does not keep syncing it. Run another import when you want fresh data.
</Note>

If the connected account cannot read contact lists, the HubSpot row offers **Reconnect**. After reconnecting, Migma returns you to the same import flow, and CSV or paste import remains available as a fallback.

## Related docs

<CardGroup>
  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Compare platform export and file export.
  </Card>

  <Card title="Platform Integrations" icon="puzzle-piece" href="/integrations/platform-integrations">
    See how HubSpot differs from sending providers.
  </Card>
</CardGroup>


# Klaviyo Integration
Source: https://docs.migma.ai/integrations/klaviyo

Use Klaviyo when your team wants Migma to prepare the email and Klaviyo to own lists, flows, profiles, campaign scheduling, or final sending.

Use Klaviyo when your team wants Migma to prepare the email and Klaviyo to own lists, flows, profiles, campaign scheduling, or final sending.

## What you can do

<CardGroup>
  <Card title="Connect with OAuth" icon="key">
    Authorize Klaviyo from brand integrations.
  </Card>

  <Card title="Export templates" icon="document-plus">
    Save reviewed emails as HTML templates, or as beta editable templates for Klaviyo's editor.
  </Card>

  <Card title="Create draft campaign work" icon="paper-plane">
    Send finished email work to Klaviyo for final review where supported.
  </Card>

  <Card title="Preserve Liquid syntax" icon="code-bracket">
    Keep Klaviyo variables such as `{{ first_name }}` and conditional Liquid blocks.
  </Card>
</CardGroup>

## Connect Klaviyo

Open [Klaviyo connections in Migma](https://migma.ai/integrations/klaviyo/settings) to choose the brand you want to connect. If Klaviyo sends you to Migma from its App Marketplace, [the install link](https://migma.ai/integrations/klaviyo/install) returns you to the connection flow after sign-in.

<Steps>
  <Step title="Open brand integrations">
    Open **Settings → Integrations → Klaviyo**, choose a brand, then find **Klaviyo** under its integrations.
  </Step>

  <Step title="Click Connect">
    Sign in to Klaviyo and approve access.
  </Step>

  <Step title="Confirm the connected account">
    Migma shows the connected Klaviyo account before export.
  </Step>
</Steps>

## Disconnect Klaviyo

Open [Klaviyo connections in Migma](https://migma.ai/integrations/klaviyo/settings), choose the connected brand, then select its **Disconnect** control. Migma asks Klaviyo to revoke the connection before removing it from the brand. If Klaviyo cannot confirm revocation, Migma keeps the connection and shows an error so you can retry.

<Note>
  Legacy private-key connections created before OAuth rollout continue to work until they are disconnected. New setup should use OAuth.
</Note>

## Export to Klaviyo

<Steps>
  <Step title="Review the email in Migma">
    Check copy, links, rendering, mobile behavior, and preflight.
  </Step>

  <Step title="Open Publish">
    Choose **Klaviyo** from export destinations.
  </Step>

  <Step title="Export the email">
    **Create HTML template** is the primary handoff and keeps the reviewed layout. **Adapt for Klaviyo editor** is beta: Migma prepares a simpler version if needed, creates the editable template, then shows **Open in Klaviyo**.
  </Step>

  <Step title="Finish in Klaviyo">
    Review the result, choose the list, segment, campaign, or flow, then send from Klaviyo.
  </Step>
</Steps>

The Klaviyo panel includes **Adapt for Klaviyo editor**. It creates an editable template in Klaviyo and shows **Open in Klaviyo**, the same success as HTML export. Adapting does not change the email on your canvas. It uses half an email credit.

## Liquid variables

Migma preserves Klaviyo Liquid syntax that you include in the email.

```text theme={null}
Create an abandoned cart reminder for Klaviyo.
Use {{ first_name|default:"there" }} in the greeting and {{ event.product_name }} for the product.
```

Common patterns:

| Pattern | Use |
| - | - |
| `{{ first_name }}` | Profile property |
| `{{ person.company }}` | Custom profile property |
| `{{ event.product_name }}` | Event property |
| `{% if person.vip_status %}` | Conditional content |

<Warning>
  Klaviyo validates variables against profile, event, list, and flow data. Preview with real Klaviyo test profiles before sending.
</Warning>

## Import contacts from Klaviyo

Bring an existing Klaviyo list or segment into Migma without exporting a CSV. Imports read from your connected Klaviyo account and run in the background.

<Steps>
  <Step title="Start from Contacts">
    In **Audience**, click **Add Contact** then **Import from integration** and choose **Klaviyo**. If Klaviyo is not connected yet, connect it from the same screen.
  </Step>

  <Step title="Choose a source">
    Pick the list or segment you want to import.
  </Step>

  <Step title="Confirm consent behavior">
    By default Migma imports contacts with email consent only. You can optionally include suppressed and never-subscribed profiles for record keeping, and those contacts stay non-sendable in Migma.
  </Step>

  <Step title="Start the import">
    The import runs as a background job. Watch progress in the dialog, or check **Import History** for the final counts.
  </Step>
</Steps>

Every import creates a source tag named after the list or segment, such as `Newsletter`, and a snapshot segment that targets it, so the imported audience is immediately usable. Importing the same source again reuses the same tag and segment, and each import still gets its own **Import History** record showing the provider, account, source, consent mode, and how many contacts were imported, updated, kept non-sendable, skipped, or failed.

<Note>
  Imports are one-time snapshots. Migma copies the selected source at import time and does not keep syncing it. Run another import when you want fresh data. Existing Migma contacts that unsubscribed or bounced are never resubscribed by an import.
</Note>

If the connected account cannot read lists and segments, the Klaviyo row offers **Reconnect**. Klaviyo connections created before contact import was available may need this once to allow reading contacts. After reconnecting, Migma returns you to the same import flow, and CSV or paste import remains available as a fallback.

## Related docs

<CardGroup>
  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Compare Klaviyo export with other destinations.
  </Card>

  <Card title="Migma vs Klaviyo" icon="scale-balanced" href="/comparisons/migma-vs-klaviyo">
    Compare Migma and Klaviyo workflows.
  </Card>
</CardGroup>


# Mailchimp Integration
Source: https://docs.migma.ai/integrations/mailchimp

Use Mailchimp when your team wants Migma to prepare the email, then Mailchimp should own the final audience, journey, schedule, or send.

Use Mailchimp when your team wants Migma to prepare the email, then Mailchimp should own the final audience, journey, schedule, or send.

## What you can do

<CardGroup>
  <Card title="Connect with OAuth" icon="key">
    Authorize Mailchimp from brand integrations. No new API key copy-paste is required for new connections.
  </Card>

  <Card title="Export templates" icon="download">
    Save reviewed Migma emails into Mailchimp templates.
  </Card>

  <Card title="Create draft campaigns" icon="paper-plane">
    Prepare a Mailchimp campaign draft when the export flow supports campaign handoff.
  </Card>

  <Card title="Preserve merge tags" icon="tag">
    Keep Mailchimp merge tags such as `*|FNAME|*` in exported HTML.
  </Card>
</CardGroup>

## Connect Mailchimp

<Steps>
  <Step title="Open brand integrations">
    Open the brand, then go to **Integrations** and find **Mailchimp** under export destinations.
  </Step>

  <Step title="Click Connect">
    Sign in to Mailchimp and approve access for the account this brand should use.
  </Step>

  <Step title="Confirm the connected account">
    Migma shows the connected Mailchimp account before export so you can verify the destination.
  </Step>
</Steps>

<Note>
  Legacy API-key connections created before OAuth rollout continue to work until they are disconnected. New setup should use OAuth.
</Note>

## Export to Mailchimp

<Steps>
  <Step title="Review the email in Migma">
    Check copy, links, rendering, mobile behavior, and preflight.
  </Step>

  <Step title="Open Publish">
    Choose **Mailchimp** from export destinations.
  </Step>

  <Step title="Choose the handoff">
    Export a template or campaign draft, depending on the available action in Publish.
  </Step>

  <Step title="Finish in Mailchimp">
    Review the result, confirm audience and automation settings, then send from Mailchimp.
  </Step>
</Steps>

## Merge tags

Migma preserves Mailchimp merge tags that you include in your prompt or edit into the email.

```text theme={null}
Create a welcome email that starts with "Hi *|FNAME:there|*".
Include the Mailchimp unsubscribe link token *|UNSUB|* in the footer.
```

Common Mailchimp tokens:

| Token | Meaning |
| - | - |
| `*\|FNAME\|*` | First name |
| `*\|LNAME\|*` | Last name |
| `*\|EMAIL\|*` | Email address |
| `*\|UNSUB\|*` | Unsubscribe link |
| `*\|UPDATE_PROFILE\|*` | Preference update link |

<Warning>
  Mailchimp handles final merge-tag validation. Preview with Mailchimp audience data before sending.
</Warning>

## Import contacts from Mailchimp

Bring an existing Mailchimp audience into Migma without exporting a CSV. Imports read from your connected Mailchimp account and run in the background.

<Steps>
  <Step title="Start from Contacts">
    In **Audience**, click **Add Contact** then **Import from integration** and choose **Mailchimp**. If Mailchimp is not connected yet, connect it from the same screen.
  </Step>

  <Step title="Choose a source">
    Pick the audience, saved segment, or tag you want to import.
  </Step>

  <Step title="Confirm consent behavior">
    By default Migma imports subscribed contacts only. You can optionally include non-subscribed and unsubscribed contacts for record keeping, and those contacts stay non-sendable in Migma.
  </Step>

  <Step title="Start the import">
    The import runs as a background job. Watch progress in the dialog, or check **Import History** for the final counts.
  </Step>
</Steps>

Every import creates a source tag named after the audience, such as `Main Audience`, and a snapshot segment that targets it, so the imported audience is immediately usable. Importing the same source again reuses the same tag and segment, and each import still gets its own **Import History** record showing the provider, account, source, consent mode, and how many contacts were imported, updated, kept non-sendable, skipped, or failed.

<Note>
  Imports are one-time snapshots. Migma copies the selected source at import time and does not keep syncing it. Run another import when you want fresh data. Existing Migma contacts that unsubscribed or bounced are never resubscribed by an import.
</Note>

If the connected account cannot read contacts, the Mailchimp row offers **Reconnect**. After reconnecting, Migma returns you to the same import flow. CSV or paste import remains available as a fallback.

## Troubleshooting

<AccordionGroup>
  <Accordion title="Mailchimp is not connected">
    Reconnect from brand integrations, then return to Publish and refresh the export destination.
  </Accordion>

  <Accordion title="Merge tags show as raw text">
    Confirm the syntax matches Mailchimp merge tags and test with a Mailchimp contact that has the field populated.
  </Accordion>

  <Accordion title="Export fails">
    Check that the connected Mailchimp account is active and that the audience or destination still exists.
  </Accordion>
</AccordionGroup>

## Related docs

<CardGroup>
  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Compare Mailchimp export with other destinations.
  </Card>

  <Card title="Migma vs Mailchimp" icon="scale-balanced" href="/comparisons/migma-vs-mailchimp">
    Compare Migma and Mailchimp workflows.
  </Card>
</CardGroup>


# Mailgun Integration
Source: https://docs.migma.ai/integrations/mailgun

Use Mailgun when your team already manages delivery infrastructure in Mailgun and wants Migma-created emails to use that provider.

Use Mailgun when your team already manages delivery infrastructure in Mailgun and wants Migma-created emails to use that provider.

## What Mailgun does in Migma

<CardGroup>
  <Card title="Delivery provider" icon="paper-plane">
    Migma owns the send workflow and Mailgun handles delivery.
  </Card>

  <Card title="Existing sender setup" icon="server">
    Good fit when Mailgun already manages your sending domain and delivery rules.
  </Card>

  <Card title="Campaign and API sends" icon="code-bracket">
    Use Mailgun as the selected provider for Migma sends.
  </Card>

  <Card title="Review before send" icon="shield-check">
    Test the email and sender setup before approving campaign delivery.
  </Card>
</CardGroup>

## Setup checklist

<Steps>
  <Step title="Prepare Mailgun">
    Confirm the sending domain is verified and ready in Mailgun.
  </Step>

  <Step title="Connect Mailgun in Migma">
    Open **Settings** and connect Mailgun under email providers. Use your Mailgun account API key, not a domain sending key: Migma adds a signed webhook to the sending domain so sends, deliveries, bounces and complaints appear in campaign results and bounced or complaining contacts are suppressed.
  </Step>

  <Step title="Choose Mailgun for delivery">
    Select Mailgun when sending from Migma or through the API.
  </Step>

  <Step title="Monitor results">
    Review Migma logs and Mailgun delivery status after sending.
  </Step>
</Steps>

## Related docs

<CardGroup>
  <Card title="Email Service Providers" icon="envelope" href="/integrations/email-service-providers">
    Compare direct sending providers.
  </Card>

  <Card title="Sending Domains" icon="globe" href="/sending-domains/overview">
    Prepare sender identity and domain health.
  </Card>
</CardGroup>


# External MCP Servers
Source: https://docs.migma.ai/integrations/mcp-servers

Connect approved external MCP servers so Migma can use tool and data context from other systems while preparing email drafts for human review.

External MCP servers let Migma use approved tool context from other systems while preparing email work. Use them when the email should reference live product, customer, document, task, billing, or internal data.

<Info>
  Looking for Migma's MCP server for Claude, Cursor, Codex, ChatGPT, or another AI client? Use [Migma MCP](/mcp-server).
</Info>

## What external MCP servers do

<CardGroup>
  <Card title="Pull tool context" icon="server">
    Let Migma search or read approved data from connected tools.
  </Card>

  <Card title="Support custom sources" icon="wrench-screwdriver">
    Add built-in servers or a custom MCP server URL for your own systems.
  </Card>

  <Card title="Keep approval visible" icon="shield-check">
    Migma shows tool access and approval controls before sensitive actions.
  </Card>

  <Card title="Improve email context" icon="document-magnifying-glass">
    Use product, customer, roadmap, billing, or knowledge-base data in email creation.
  </Card>
</CardGroup>

## Common sources

Built-in options include:

* Shopify for products, inventory, customers, and orders.
* Stripe for customers, subscriptions, invoices, and payment context.
* Notion and Airtable for content plans, databases, and knowledge bases.
* Linear, Asana, ClickUp, and Close for project, sales, and customer context.
* Canva for design context.
* PayPal and Square for payment and commerce context.
* Custom MCP servers for proprietary product, warehouse, CRM, or analytics data.

## Connect an external MCP server

<Steps>
  <Step title="Open brand settings">
    Open the brand's settings, then go to **MCP Servers**. The settings sidebar search also finds connectors by name, like Notion or Stripe.
  </Step>

  <Step title="Choose a built-in server or custom URL">
    Select a listed server, or add your own MCP server endpoint.
  </Step>

  <Step title="Complete auth if needed">
    Some servers require OAuth or provider approval. Authless servers can be tested directly.
  </Step>

  <Step title="Enable tools">
    Review available tools, enable only what this brand needs, and save.
  </Step>

  <Step title="Use in email creation">
    Ask Migma to use the connected source while preparing email work.
  </Step>
</Steps>

## Best practices

* Connect only sources that contain data appropriate for this brand.
* Enable the smallest useful tool set.
* Review generated content before send or export.
* Disconnect unused servers to keep tool access clear.
* Use [Migma MCP](/mcp-server) when an AI client should control Migma. Use external MCP when Migma should read another tool.

## Related docs

<CardGroup>
  <Card title="Shopify" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/shopify.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=06c6846e98cbe8dc5a835a8103948be8" href="/integrations/shopify">
    Use Shopify store context in email work.
  </Card>

  <Card title="Stripe" icon="credit-card" href="/integrations/stripe">
    Use billing and customer lifecycle context.
  </Card>

  <Card title="Migma MCP" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/mcp-server.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f5f7603fbb9a215d6bfd3b6390062008" href="/mcp-server">
    Connect AI tools to Migma.
  </Card>

  <Card title="n8n" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/n8n.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=c3abd117b555ded67bed51cbae5d9802" href="/n8n">
    Automate Migma from workflow nodes.
  </Card>
</CardGroup>


# Omnisend Integration
Source: https://docs.migma.ai/integrations/omnisend

Connect Omnisend to Migma, prepare and preflight an email, then export it as a draft campaign for audience selection, review, and sending in Omnisend.

Use Omnisend when Migma should prepare the email and Omnisend should own the campaign review, audience, and final send.

## What you can do

<CardGroup>
  <Card title="Connect with OAuth" icon="key">
    Authorize Omnisend from brand integrations.
  </Card>

  <Card title="Create draft campaigns" icon="document-plus">
    Export a reviewed Migma email to Omnisend as a draft.
  </Card>

  <Card title="Use Omnisend segments" icon="users">
    Select Omnisend recipients when the export flow needs an audience.
  </Card>

  <Card title="Keep review in place" icon="eye">
    Finish campaign checks and final approval in Omnisend.
  </Card>
</CardGroup>

## Connect Omnisend

<Steps>
  <Step title="Open brand integrations">
    Open the brand, then go to **Integrations**.
  </Step>

  <Step title="Click Connect">
    Choose **Omnisend**, sign in, and approve access.
  </Step>

  <Step title="Confirm status">
    Migma shows the connected account before export.
  </Step>
</Steps>

## Export to Omnisend

<Steps>
  <Step title="Review the email">
    Confirm the email is ready in Migma.
  </Step>

  <Step title="Open Publish">
    Choose **Omnisend** from export destinations.
  </Step>

  <Step title="Export draft">
    Migma creates an Omnisend draft campaign when export succeeds.
  </Step>

  <Step title="Finish in Omnisend">
    Review the draft, confirm audience and schedule, then approve the send in Omnisend.
  </Step>
</Steps>

<Info>
  Omnisend is an export destination. If you want Migma to own the campaign send, use Migma sending or a connected delivery provider instead.
</Info>

## Related docs

<CardGroup>
  <Card title="Export Options" icon="download" href="/email-editor/export-options">
    Export from Publish to Omnisend or other destinations.
  </Card>

  <Card title="Campaigns vs Series" icon="arrows-right-left" href="/campaigns/campaigns-vs-email-series">
    Decide when to use Migma campaigns, series, or external automation.
  </Card>
</CardGroup>


# Migma Email Platform Integrations
Source: https://docs.migma.ai/integrations/overview

Connect Migma to design tools, AI assistants, business data, chat apps, email platforms, and delivery providers while keeping review in one workflow.

<Frame>
  <img alt="Illustration of Migma connected to design sources, business context, chat tools, and email platforms" />
</Frame>

Migma connects the work around email. Start from a design, ask from an AI assistant, use approved business context, then review one result in Migma before sending or exporting.

## Start where the work already lives

<CardGroup>
  <Card title="Figma, screenshots, and HTML" icon="download" href="/creating-emails/overview">
    Turn existing work into an editable email instead of rebuilding it by hand.
  </Card>

  <Card title="Claude" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/tutorials/connect-migma-to-claude-code">
    Plan and request emails in Claude. Open the finished drafts on the Migma canvas.
  </Card>

  <Card title="ChatGPT" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/tutorials/connect-migma-to-chatgpt">
    Work from ChatGPT while Migma keeps brand, audience, compatibility, and sending controls.
  </Card>

  <Card title="Slack" icon="comments" href="/integrations/slack">
    Start email work from team chat, then review the result in Migma.
  </Card>

  <Card title="Telegram" icon="paper-plane" href="/integrations/telegram">
    Message Migma from Telegram to create or change a draft, then open it in Migma.
  </Card>
</CardGroup>

## Use context without copying it by hand

<CardGroup>
  <Card title="Shopify" icon="cart-shopping" href="/integrations/shopify">
    Use store, product, customer, and order context when it helps the email.
  </Card>

  <Card title="Stripe" icon="credit-card" href="/integrations/stripe">
    Use customer, subscription, invoice, and payment context when it is relevant.
  </Card>

  <Card title="Other approved tools" icon="database" href="/integrations/mcp-servers">
    Let Migma use selected data and actions from tools your team connects.
  </Card>

  <Card title="Your brand workspace" icon="palette" href="/get-started/configure-brand">
    Keep logos, colors, fonts, products, voice, and saved references ready for every email.
  </Card>
</CardGroup>

## Review once, then send your way

<Steps>
  <Step title="Review the email in Migma">
    Change copy or design, run **Email Preflight**, and send yourself a test.
  </Step>

  <Step title="Choose the destination">
    Open **Publish**. Send with Migma, export to Mailchimp, Klaviyo, Omnisend, Brevo, or an existing HubSpot connection, or use the API.
  </Step>

  <Step title="Approve live action">
    You choose when to send or schedule, directly or by approving your agent's request.
  </Step>
</Steps>

<Note>
  Some connections are limited or still rolling out. Each setup page shows what is available before you connect.
</Note>

## Next

<CardGroup>
  <Card title="Choose an email platform" icon="arrow-up-tray" href="/integrations/platform-integrations">
    Compare import, context, export, and sending connections.
  </Card>

  <Card title="Check inbox compatibility" icon="mobile" href="/email-editor/client-compatibility">
    Review Outlook, Gmail, mobile, light mode, and dark mode before handoff.
  </Card>
</CardGroup>


# Platform Integrations
Source: https://docs.migma.ai/integrations/platform-integrations

Choose a Migma integration for importing designs or contacts, exporting reviewed emails, sending through a provider, or using external business data.

Connect the tools that already own part of your email workflow. Migma prepares and checks the email. You choose where the final review and send happen.

## Choose the job

| Job | Use |
| - | - |
| Start from a design | [Figma](/integrations/figma), screenshot, HTML, or [Claude design](/creating-emails/claude-design) |
| Work from an AI assistant | [Claude](/tutorials/connect-migma-to-claude-code), [ChatGPT](/tutorials/connect-migma-to-chatgpt), or [Migma MCP](/mcp-server) |
| Export to an email platform | [Mailchimp](/integrations/mailchimp), [Klaviyo](/integrations/klaviyo), [HubSpot](/integrations/hubspot), [Omnisend](/integrations/omnisend), or [Brevo](/integrations/brevo) |
| Send through Migma | [Migma sending](/sending-domains/overview), [Amazon SES](/integrations/amazon-ses), [Resend](/integrations/resend), [SendGrid](/integrations/sendgrid), or [Mailgun](/integrations/mailgun) |
| Use business data while writing | [Shopify](/integrations/shopify), [Stripe](/integrations/stripe), or an [external MCP server](/integrations/mcp-servers) |
| Work from chat or automation | [Slack](/integrations/slack), [Telegram](/integrations/telegram), [n8n](/n8n), or [webhooks](/webhooks) |

## Where connections live

Open **Settings → Integrations**. **Sending providers** manages delivery through Migma, Amazon SES, Resend, SendGrid, or Mailgun. **Marketing platforms** opens a brand picker for Mailchimp, Klaviyo, HubSpot, Omnisend, or Brevo; each connection belongs to the chosen brand.

<CardGroup>
  <Card title="Brand integrations" icon="folder" href="/settings/overview">
    Connect Figma and email-platform export destinations for one brand.
  </Card>

  <Card title="Brand tools" icon="wrench" href="/integrations/mcp-servers">
    Connect external MCP servers that Migma can use while preparing email.
  </Card>

  <Card title="Settings → Integrations" icon="building-office" href="/settings/overview">
    Connect Slack, Telegram, and supported delivery providers for the workspace.
  </Card>

  <Card title="Publish → Export" icon="arrow-up-tray" href="/email-editor/export-options">
    Send the focused, reviewed email to a connected platform or file.
  </Card>
</CardGroup>

## Marketing platform or sending provider?

| Choice | What happens |
| - | - |
| **Marketing platform** | The platform owns the audience and delivery. Publish supports direct sending through connected Mailchimp, Klaviyo, and HubSpot accounts, or export for review in the platform. Omnisend and Brevo use export handoff. |
| **Sending provider** | Migma owns the campaign or API send. The chosen provider delivers it. |

Use a marketing platform when it already owns your audience or automations. Use a sending provider when Migma should own the send and results. Publish shows the available action for the selected platform; exporting a draft or template does not send it.

## Review before anything leaves Migma

<Steps>
  <Step title="Prepare the email">
    Create or import the email, then review it on the canvas.
  </Step>

  <Step title="Check it">
    Run Email Preflight, check mobile and dark mode, and send yourself a test.
  </Step>

  <Step title="Choose the destination">
    Open **Publish**, then choose Migma sending, a connected platform, a file, or the API.
  </Step>

  <Step title="Review again in the destination">
    Confirm the subject, sender, audience, variables, and timing before the final send.
  </Step>
</Steps>

## Provider guides

<CardGroup>
  <Card title="Figma" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/figma.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=1388542bde3d29ae9480addef82339cf" href="/integrations/figma">Import frames or hand work back to design.</Card>
  <Card title="Mailchimp" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/mailchimp.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=0bea60e5e61859be5623889f5d201a8b" href="/integrations/mailchimp">Export templates or draft campaigns.</Card>
  <Card title="Klaviyo" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/klaviyo.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=19ee0306b3ebb901417cf42b1c2745b4" href="/integrations/klaviyo">Export HTML or a beta editable version.</Card>
  <Card title="HubSpot" icon="building-office" href="/integrations/hubspot">Use an existing HubSpot connection.</Card>
  <Card title="Omnisend" icon="envelope" href="/integrations/omnisend">Export draft campaigns.</Card>
  <Card title="Brevo" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/brevo.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=02cecab7f957d430eaa1015cac2b23be" href="/integrations/brevo">Export reusable templates.</Card>
</CardGroup>


# Resend Integration
Source: https://docs.migma.ai/integrations/resend

Use Resend when your team already sends application or lifecycle email through Resend and wants Migma-created emails to use that delivery path.

Use Resend when your team already sends application or lifecycle email through Resend and wants Migma-created emails to use that delivery path.

## What Resend does in Migma

<CardGroup>
  <Card title="Delivery provider" icon="paper-plane">
    Migma owns the email workflow and Resend handles delivery.
  </Card>

  <Card title="Developer-friendly setup" icon="code-bracket">
    Good fit for teams that already use Resend for app email.
  </Card>

  <Card title="Verified domain required" icon="shield-check">
    Use a sender domain approved for Resend delivery.
  </Card>

  <Card title="Works with Migma APIs" icon="terminal">
    Select Resend when using Migma sends from app code or CLI workflows.
  </Card>
</CardGroup>

## Setup checklist

<Steps>
  <Step title="Prepare Resend">
    Make sure your sending domain is verified in Resend.
  </Step>

  <Step title="Connect Resend in Migma">
    Open **Settings** and connect Resend under email providers. Use an API key with full access: Migma adds a signed webhook to your Resend account so sends, deliveries, bounces and complaints appear in campaign results and bounced or complaining contacts are suppressed.
  </Step>

  <Step title="Choose Resend for delivery">
    Select Resend when sending from Migma or through the API.
  </Step>

  <Step title="Send a test">
    Check rendering, sender, reply-to, and tracking before campaign approval.
  </Step>
</Steps>

## Related docs

<CardGroup>
  <Card title="Migma vs Resend" icon="scale-balanced" href="/comparisons/migma-vs-resend">
    Compare creation, sending, and developer workflows.
  </Card>

  <Card title="Email Service Providers" icon="envelope" href="/integrations/email-service-providers">
    Compare direct sending providers.
  </Card>
</CardGroup>


# SendGrid Integration
Source: https://docs.migma.ai/integrations/sendgrid

Use SendGrid when your team already runs delivery through Twilio SendGrid and wants Migma-created emails to use that provider.

Use SendGrid when your team already runs delivery through Twilio SendGrid and wants Migma-created emails to use that provider.

## What SendGrid does in Migma

<CardGroup>
  <Card title="Delivery provider" icon="paper-plane">
    Migma prepares the email and SendGrid handles delivery.
  </Card>

  <Card title="Existing infrastructure" icon="server">
    Good fit when your domain, suppression, or reporting setup already lives in SendGrid.
  </Card>

  <Card title="Campaign and API sends" icon="code-bracket">
    Use SendGrid as the selected provider for Migma sends.
  </Card>

  <Card title="Test before launch" icon="shield-check">
    Confirm sender, links, rendering, and provider status before approving a campaign.
  </Card>
</CardGroup>

## Setup checklist

<Steps>
  <Step title="Prepare SendGrid">
    Confirm the sender or domain is authenticated in SendGrid.
  </Step>

  <Step title="Connect SendGrid in Migma">
    Open **Settings** and connect SendGrid under email providers. The API key needs Mail Send and Event Webhook access: Migma adds a signed Event Webhook to your account so sends, deliveries, bounces and spam reports appear in campaign results and bounced or complaining contacts are suppressed. If your plan has no free webhook slot, Migma shows a webhook URL to add in SendGrid.
  </Step>

  <Step title="Choose SendGrid for delivery">
    Select SendGrid when sending from Migma or through the API.
  </Step>

  <Step title="Review results">
    Monitor Migma campaign state and SendGrid delivery state after sending.
  </Step>
</Steps>

## Related docs

<CardGroup>
  <Card title="Migma vs SendGrid" icon="scale-balanced" href="/comparisons/migma-vs-sendgrid">
    Compare Migma and SendGrid workflows.
  </Card>

  <Card title="Email Service Providers" icon="envelope" href="/integrations/email-service-providers">
    Compare direct sending providers.
  </Card>
</CardGroup>


# Shopify Integration
Source: https://docs.migma.ai/integrations/shopify

Connect Shopify so Migma can use approved product, inventory, customer, and order context when preparing ecommerce email drafts and campaigns.

Use Shopify when product, inventory, customer, or order context should shape email creation.

Shopify connects as an MCP data source. Migma can use the connected store while preparing email work, but you still review and approve any email before export or send.

## What you can do

<CardGroup>
  <Card title="Use product context" icon="shopping-bag">
    Reference products, images, URLs, inventory, and store information when creating email.
  </Card>

  <Card title="Use customer and order context" icon="users">
    Prepare lifecycle, win-back, post-purchase, or product-recommendation emails with store context.
  </Card>

  <Card title="Connect by store URL" icon="link">
    Add a Shopify MCP server from the setup flow or MCP server tools.
  </Card>

  <Card title="Review before action" icon="eye">
    Migma prepares content. You approve final send, export, or schedule.
  </Card>
</CardGroup>

## Connect Shopify

<Steps>
  <Step title="Open setup or tools">
    Connect Shopify during setup, or open the brand's MCP server tools and choose **Shopify**.
  </Step>

  <Step title="Enter the store URL">
    Enter the full store URL or Shopify subdomain. Migma uses the store MCP endpoint to test available tools.
  </Step>

  <Step title="Enable tools">
    Migma tests the connection and enables available Shopify tools for the brand.
  </Step>

  <Step title="Use Shopify in prompts">
    Ask Migma to use store products, collections, customers, or orders when preparing the email.
  </Step>
</Steps>

## Prompt examples

```text theme={null}
Create a product launch email using the top products from my Shopify store.
Show product names, current prices, images, and links.
```

```text theme={null}
Prepare a post-purchase follow-up for customers who bought running shoes.
Use Shopify order context where available, but do not invent purchase details.
```

## Access and control

* Shopify is used as context for email preparation.
* You review the generated email before send or export.
* Disconnect Shopify from the same MCP server or integration surface where it was added.
* If Shopify is not connected, use manual product details, CSV data, or pasted references instead.

## Related docs

<CardGroup>
  <Card title="External MCP" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/mcp-server.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f5f7603fbb9a215d6bfd3b6390062008" href="/integrations/mcp-servers">
    Connect Shopify and other external data tools.
  </Card>

  <Card title="Create Emails" icon="wand-magic-sparkles" href="/creating-emails/overview">
    Use connected context while preparing email work.
  </Card>
</CardGroup>


# Migma for Slack
Source: https://docs.migma.ai/integrations/slack

Install Migma in Slack, link your account, and run brand setup, email design, audience imports, domain setup, and campaign sends from a DM or channel thread.

Install Migma in your Slack workspace, link your account, then message Migma in a direct message or mention `@Migma` in a channel. You can import a brand, design emails, set up a sending domain, import an audience, create a campaign, and send or schedule it from the same thread.

<Frame>
  <img alt="Migma and Slack logos above a prompt that says @Migma prepare our launch email" />
</Frame>

<Note>
  Migma for Slack is in beta and rolling out. Some workspaces may not have access yet.
</Note>

## Before you start

You need:

* A Migma account
* Permission to install apps in your Slack workspace
* A Slack workspace where you can invite and mention apps

The Migma app is installed once per workspace. Each teammate links their own Migma account before using it.

## Connect Migma in five steps

<Steps>
  <Step title="Open the Slack integration">
    In Migma, open **Settings → Integrations**, find **Slack** under **Chat**, then select it.

    You can also [add Migma to Slack directly](https://api.migma.ai/slack/install).

    <Frame>
      <img alt="Migma Settings showing the Slack integration under Chat" />
    </Frame>
  </Step>

  <Step title="Choose a workspace and approve access">
    Select the correct Slack workspace, review the requested permissions, then select **Allow**.

    Migma needs access to read messages that mention the bot, reply in threads, and upload preview files. If your workspace restricts app installations, a Slack owner may need to approve it first.

    <Frame>
      <img alt="Slack permission screen for adding Migma to a workspace" />
    </Frame>
  </Step>

  <Step title="Message Migma in Slack">
    In a direct message to Migma, send a request without an `@` mention. In a channel where Migma is present, mention `@Migma`, for example:

    ```text theme={null}
    @Migma prepare 3 launch emails for Allbirds. Show me the previews.
    ```

    Your first message returns a **Connect Migma** button. Select it to link your personal Migma account.

    Workspaces that installed Migma before direct-message support may need to [reinstall the app](https://api.migma.ai/slack/install) once so Migma can receive DMs.

    <Frame>
      <img alt="Slack thread showing a Connect Migma button after the first mention" />
    </Frame>
  </Step>

  <Step title="Link your Migma account">
    Sign in to Migma if needed, confirm the account shown, then select **Continue with Slack**.

    This links your verified Slack identity to your Migma account. Never paste a Migma API key into Slack.

    <Frame>
      <img alt="Migma account-link screen with a Continue with Slack button" />
    </Frame>
  </Step>

  <Step title="Return to Slack and send the request again">
    Return to the channel and mention `@Migma` again. The request that opened the connection flow is not resumed automatically.

    Migma replies in a thread with previews, links, and next steps. Use **Open in Migma** to continue editing or download HTML. You can also finish domain setup, imports, and sends in the thread.

    <Frame>
      <img alt="Slack thread with three email previews and an Open in Migma button" />
    </Frame>
  </Step>
</Steps>

## What the connection allows

| Connection | What it does |
| - | - |
| Slack workspace install | Lets people mention `@Migma`, receive replies, and view preview files |
| Personal Migma link | Gives the bot your scoped Migma access when it handles your mentions |

<Info>
  After the workflow-tools release, new account links approve access to Migma email, audience, campaign, domain, webhook and billing tools. Sending or scheduling requires a send summary and your confirmation in chat. Contact deletion and external changes also require approval. Billing checkouts are opened and completed by you. Existing links keep their original scopes; disconnect and reconnect to review broader access.
</Info>

In channels, Migma processes messages that mention the bot. In a direct message, every message goes to Migma. Unrelated channel messages are not sent into the Migma reply flow.

When Migma needs a choice, such as which segment to target, it shows answer buttons. Tapping a button is the same as typing the answer. Only the person who asked can respond to those buttons.

## Approve sends in chat

Before Migma sends or schedules a campaign, it posts a summary with the subject, audience, recipient count, sender, send time, and an inbox rendering score. Confirm with **Send** or **Cancel**, or reply in the thread. You approve every send. If you change the campaign after the summary appears, Migma shows a new summary before anything goes out.

Migma posts in the same chat when a domain finishes connecting, an import finishes, or a send completes. Ask for opens and clicks when you want campaign results.

## What you can ask

Talk to Migma in plain language:

| Ask | Result |
| - | - |
| `@Migma create 3 emails for Stripe and show me images` | Three on-brand email drafts with preview images |
| `@Migma create a welcome email and give me the HTML` | An email draft plus a `.html` file |
| `@Migma import stripe.com and make 2 onboarding emails` | Imports the brand, then prepares the drafts |
| `@Migma import our VIP segment from Klaviyo and schedule a launch for tomorrow` | Imports the audience, designs the email, and prepares a send summary |
| `@Migma make it shorter` in the same thread | Edits the email already in that thread |
| `@Migma make email 2 more formal` | Edits one email in a set |
| `@Migma show me welcome email inspiration` | Finds real brand examples for ideas on supported plans |

You can also attach a screenshot and say `@Migma make an email like this for Stripe`.

Example thread:

```text theme={null}
You: @Migma import acme.com, pull our VIP list from Klaviyo, design a launch email, and send tomorrow at 9am Eastern

Migma: [Acme logo] Brand imported. [Email previews]. Klaviyo import started. [Domain DNS link]. Send summary: subject, 4,200 recipients… [Send] [Cancel]

You: Send

Migma: Scheduled for tomorrow 9:00 AM ET. I'll post here when the send finishes.
```

## Channels, threads, and brands

* In channels, mention `@Migma` for each new request. In a direct message, send your request without a mention.
* Keep follow-up edits in the same thread so Migma has the right context.
* Invite Migma to a private channel before mentioning it there.
* Name another brand or paste its website when you want to switch brands.

When you name a brand, Migma checks your existing brands first. If none match, it asks for a website and imports it.

## Disconnect

Say `@Migma disconnect`, or revoke the key named for your Slack workspace under **Migma Settings → Developers → API Keys**.

After disconnecting, Migma asks you to link your account again on your next mention.

## Audience exports and connected tools

After the release with these workflow tools is available, ask: `Export unsubscribed contacts for my brand as CSV`. The bot uses the shared Migma MCP catalog, starts an export, and checks the job for a private download link. Large exports may still be processing when a reply arrives; ask it to check status in the same thread.

For store or CRM workflows, the bot discovers tools enabled on that brand and reads their argument schemas before calling them. Existing server permissions and approval settings still apply. Tools requiring dashboard approval remain blocked in chat until you review the tool's permissions in Migma.

A CSV export does not synchronize Shopify. Shopify storefront tools do not include customer marketing-consent updates; synchronization needs a connected tool with that access. The bot must report unsupported operations and provider failures instead of claiming completion.

## Troubleshooting

### I cannot install the app

Your Slack workspace may require owner approval. Ask a workspace owner to approve Migma, then restart the install. See [Slack's guide to adding apps](https://slack.com/help/articles/202035138-Add-apps-to-your-Slack-workspace).

### Migma does not reply

Check that:

* Migma is installed in the current workspace.
* Migma is a member of the channel.
* In a channel, your message includes the exact `@Migma` mention (not required in a DM).
* You are testing in a thread or channel where apps can post.

### The Connect Migma button does not appear again

The bot limits repeated connection prompts. Wait up to one hour, then mention `@Migma` again.

### I linked my account, but my request did not run

Return to Slack and send the mention again. The original connection request is not resumed after linking.

### My link stopped working

Disconnect, link again, then retry the mention. If the problem continues, contact Migma support with your Slack workspace name and approximate time of the failed request.

## Build your own Slack app

Want a private bot or a custom workflow? Use Agent Auth, the SDK, the API, or run Migma through OpenClaw.

<CardGroup>
  <Card title="Agent Auth" icon="key" href="/agent-auth">
    Give a custom Slack app scoped access for each Migma user.
  </Card>

  <Card title="OpenClaw" icon="lobster" href="/openclaw">
    Run Migma in Slack, WhatsApp, Telegram, and Discord through OpenClaw.
  </Card>

  <Card title="SDK" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/npm.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=1839361b0494d7d3199cdaa3575846ac" href="/sdk">
    Prepare series, fetch HTML, and read preview URLs from your own code.
  </Card>

  <Card title="API reference" icon="code" href="/api-reference/introduction">
    Build custom Migma workflows with the public API.
  </Card>
</CardGroup>


# Stripe Integration
Source: https://docs.migma.ai/integrations/stripe

Connect Stripe so customer, subscription, invoice, and payment context can inform Migma email drafts for billing and lifecycle workflows.

Use Stripe when billing or customer lifecycle context should help Migma prepare email work.

Stripe is different from a sending provider. It gives Migma context such as customer, subscription, invoice, payment, or failed-payment state. Migma still sends through Migma sending or a connected delivery provider.

## What you can use Stripe for

<CardGroup>
  <Card title="Lifecycle email ideas" icon="arrows-right-left">
    Prepare onboarding, payment, invoice, renewal, failed-payment, or win-back email flows.
  </Card>

  <Card title="Customer context" icon="user">
    Use Stripe customer or subscription context when shaping email content.
  </Card>

  <Card title="Agent setup" icon="cpu-chip">
    Let an agent use Stripe app context when starting Migma setup work.
  </Card>

  <Card title="Delivery stays separate" icon="paper-plane">
    Send through Migma, Amazon SES, Resend, SendGrid, or Mailgun.
  </Card>
</CardGroup>

## Common workflows

| Stripe context | Email work Migma can prepare |
| - | - |
| Customer | Welcome, onboarding, lifecycle, or account-update email. |
| Subscription | Trial, renewal, upgrade, downgrade, cancellation, or win-back sequence. |
| Payment | Receipt follow-up, payment confirmation, or payment issue email. |
| Invoice | Invoice reminder, payment due, or failed-payment recovery. |

## Best practices

* Keep payment and customer data private.
* Review generated content before sending.
* Do not invent billing details that are not present in Stripe context.
* Use verified sending domains or a connected delivery provider before launch.

## Related docs

<CardGroup>
  <Card title="Lifecycle Email Recipes" icon="arrows-right-left" href="/recipes/lifecycle-emails">
    Prompt patterns for lifecycle and revenue emails.
  </Card>

  <Card title="Email Service Providers" icon="envelope" href="/integrations/email-service-providers">
    Choose how Migma sends the finished email.
  </Card>
</CardGroup>


# Connect Migma to Telegram
Source: https://docs.migma.ai/integrations/telegram

Connect your Migma account to @MigmaAIBot, then run brand setup, email design, audience imports, domain setup, and campaign sends from Telegram.

Connect your Migma account to [**@MigmaAIBot**](https://t.me/MigmaAIBot), then message Migma to import a brand, design emails, set up a sending domain, import an audience, create a campaign, and send or schedule it from Telegram.

<Frame>
  <img alt="Illustration of Migma connected to Telegram above a List my brands prompt" />
</Frame>

<Note>
  Migma for Telegram is in beta. Use only **@MigmaAIBot**. The profile name should be **MigmaAI**.
</Note>

## Before you start

You need:

* A Migma account
* A Telegram account
* Access to the Migma account you want Telegram to use

## Connect Telegram in four steps

<Steps>
  <Step title="Open the Migma bot">
    Go to [t.me/MigmaAIBot](https://t.me/MigmaAIBot) and select **Start Bot**. In the Telegram app, press **Start** and send a message.

    <Frame>
      <img alt="Illustration of the official MigmaAI Telegram bot profile with the @MigmaAIBot handle and Start Bot button" />
    </Frame>
  </Step>

  <Step title="Open the connection page">
    If your account is not linked, the bot replies with **Connect Migma**. Select it.

    You can also open **Settings → Integrations → Telegram** in Migma, or go directly to [migma.ai/telegram/connect](https://migma.ai/telegram/connect).

    <Frame>
      <img alt="Illustration of a Telegram chat with MigmaAI and a Connect Migma button" />
    </Frame>
  </Step>

  <Step title="Confirm your Telegram account">
    Sign in to Migma if asked, then select **Log in with Telegram**. Approve the Telegram account you want to link.

    <Frame>
      <img alt="Illustration of the Migma Telegram connection page with the Log in with Telegram button" />
    </Frame>
  </Step>

  <Step title="Return to Telegram and test the bot">
    After Migma confirms the link, return to Telegram and send a new message:

    ```text theme={null}
    Create 3 onboarding emails for Stripe
    ```

    A reply confirms the bot can recognize your Telegram account and access the permitted Migma actions.

    <Frame>
      <img alt="Illustration of MigmaAI returning three Stripe onboarding email drafts in Telegram" />
    </Frame>
  </Step>
</Steps>

<Info>
  Linking does not replay the message that opened the connection flow. Send a new message after returning to Telegram.
</Info>

## What Migma can access

Telegram confirms your account id and username so Migma can recognize you. Migma processes messages, captions, and images you send directly to the bot, plus group messages that mention the bot. It does not access unrelated chats or your contacts.

Migma keeps recent bot-thread context so follow-up requests such as `Make it shorter` can refer to the email already discussed. One Telegram account links to one Migma account.

<Warning>
  Never paste a Migma API key into Telegram. Use only the **Connect Migma** flow.
</Warning>

## Direct messages and groups

For direct messages, send your request to [@MigmaAIBot](https://t.me/MigmaAIBot).

For groups:

1. Add **@MigmaAIBot** to the group.
2. Mention `@MigmaAIBot` in each request.
3. Test the same request in a direct message first if the group gets no reply.

Messages without the bot mention are ignored in groups.

When Migma needs a choice, such as which segment to target, it shows answer buttons. Tapping a button is the same as typing the answer. Only the person who asked can respond to those buttons.

## Approve sends in chat

Before Migma sends or schedules a campaign, it posts a summary with the subject, audience, recipient count, sender, send time, and an inbox rendering score. Confirm with **Send** or **Cancel**, or reply in the chat. You approve every send. If you change the campaign after the summary appears, Migma shows a new summary before anything goes out.

Migma posts in the same chat when a domain finishes connecting, an import finishes, or a send completes. Ask for opens and clicks when you want campaign results.

## What you can ask

| Ask | Result |
| - | - |
| `List my brands` | Shows brands available to your Migma account |
| `Create 3 onboarding emails for Stripe` | Prepares three branded emails with previews |
| `Import our VIP list from Mailchimp and schedule a launch for tomorrow` | Imports the audience, designs the email, and prepares a send summary |
| `Make email 2 more formal` | Edits one email in the current set |
| `Show me welcome email inspiration` | Finds relevant email examples on paid plans |
| Attach an image and say `Make an email like this for Stripe` | Prepares a branded email from the reference |

Results can include preview images, DNS setup links, and download links. After the workflow-tools release, new account links approve access to Migma email, audience, campaign, domain, webhook and billing tools. Sending or scheduling requires a send summary and your confirmation in chat. Contact deletion and external changes also require approval. Billing checkouts are completed by you. Existing links keep their original scopes; disconnect and reconnect to review broader access.

Example chat:

```text theme={null}
You: Import acme.com, pull our VIP list from Klaviyo, design a launch email, and send tomorrow at 9am Eastern

Migma: [Acme logo] Brand imported. [Email previews]. Klaviyo import started. [Domain DNS link]. Send summary… [Send] [Cancel]

You: Send

Migma: Scheduled for tomorrow 9:00 AM ET. I'll post here when the send finishes.
```

## Audience exports and connected tools

After the release with these workflow tools is available, ask: `Export unsubscribed contacts for my brand as CSV`. The bot uses the shared Migma MCP catalog, starts an export, and checks the job for a private download link. Large exports may still be processing when a reply arrives; ask it to check status in the same thread.

For store or CRM workflows, the bot discovers tools enabled on that brand and reads their argument schemas before calling them. Existing server permissions and approval settings still apply. Tools requiring dashboard approval remain blocked in chat until you review the tool's permissions in Migma.

A CSV export does not synchronize Shopify. Shopify storefront tools do not include customer marketing-consent updates; synchronization needs a connected tool with that access. The bot must report unsupported operations and provider failures instead of claiming completion.

## Troubleshooting

### The bot does not reply

1. Confirm the profile shows **MigmaAI** and **@MigmaAIBot**.
2. Press **Start** in Telegram.
3. Complete the connection using the intended Migma account.
4. Return to Telegram and send a new direct message.
5. In a group, mention `@MigmaAIBot` exactly.
6. Reopen [migma.ai/telegram/connect](https://migma.ai/telegram/connect) and connect again.

If a direct message still gets no reply, email [support@migma.ai](mailto:support@migma.ai).

### Telegram connected to the wrong Migma account

Disconnect the Telegram link, sign in to the intended Migma account, then repeat the connection steps.

## Disconnect Telegram

Send `disconnect` to **@MigmaAIBot**. You can also open **Settings → Developers → API Keys** in Migma and revoke the key named for your Telegram account.

After disconnecting, the bot asks you to connect again on your next message.

## Build your own Telegram bot

Use Migma's agent auth or API if you need a separately hosted bot or custom workflow.

<CardGroup>
  <Card title="Agent Auth" icon="key" href="/agent-auth">
    Give a custom bot scoped access for each Migma user.
  </Card>

  <Card title="OpenClaw" icon="lobster" href="/openclaw">
    Run Migma in Telegram, Slack, WhatsApp, or Discord through OpenClaw.
  </Card>

  <Card title="SDK" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/npm.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=1839361b0494d7d3199cdaa3575846ac" href="/sdk">
    Generate emails, fetch HTML, and read preview URLs from code.
  </Card>

  <Card title="API reference" icon="code" href="/api-reference/introduction">
    Review the public endpoints available to your bot.
  </Card>
</CardGroup>


# Acceptable Use Policy
Source: https://docs.migma.ai/legal/acceptable-use

Rules for responsible AI use, permission-based email, brand and content rights, platform security, and reporting or reviewing abuse on Migma.

**Effective Date: September 12, 2026**

This Acceptable Use Policy forms part of Migma's [Terms of Use](/legal/terms-of-use). It applies to your use of the Services, including prompts, uploads, imported content, AI-generated outputs, Remix and gallery content, shared designs, email, exports, APIs, and connected services.

You are responsible for your content and for activity you authorize through your team, integrations, and agents. These rules also apply when you use Migma to prepare content that you distribute through another provider.

## Permission-Based Email

Migma supports newsletters, product updates, lifecycle marketing, and necessary transactional messages.

<Info>
  **Cold outreach is not allowed.** Marketing recipients must have opted in to hear from you. This is Migma's platform rule, including where local law may allow some unsolicited commercial email.
</Info>

When creating, importing, or sending email, you must:

* **Have verifiable permission for marketing.** Keep records showing how and when recipients agreed to receive the type of message you send from your brand. A public email address, CRM entry, social connection, or sales conversation alone does not establish permission.
* **Use your own permission-based audience.** Do not use purchased, rented, scraped, borrowed, harvested, or guessed lists. You may migrate your own audience from another provider if you preserve its original consent, subscription status, and suppression records.
* **Identify the sender accurately.** Use truthful sender details, subjects, offers, and links. Include required disclosures and a valid postal address where applicable. Do not forge headers or spoof another organization's domain.
* **Provide a working unsubscribe mechanism.** Honor opt-outs promptly and within applicable legal deadlines. Do not hide the mechanism, charge a fee, or require an account login to unsubscribe.
* **Respect suppression lists.** Do not send marketing to unsubscribed contacts or re-add them without fresh, verifiable permission. Do not bypass bounce, complaint, invalid-address, or manual blocks.
* **Use authorized sending infrastructure.** Send only from domains you own or are authorized to use, complete required domain authentication, and address excessive bounces or spam complaints. Do not rotate accounts, domains, or providers to evade sending restrictions.

Transactional messages must relate to a recipient's action or an existing relationship, such as an order, account, billing, security, or service event. Do not disguise promotional email as transactional email. Transactional sending must still respect hard-bounce, complaint, invalid-address, and manual blocks.

You remain responsible for applicable email and privacy laws, including CAN-SPAM, CASL, and GDPR where they apply. See [Permission-Based Sending](/get-started/what-you-can-send) for allowed use cases.

## AI-Generated Content and Claims

Review generated content before publishing or sending it, including its factual claims, links, recipients, and use of third-party material. AI output and automated checks are not proof of accuracy, ownership, permission, or legal compliance.

Do not use Migma to impersonate others, fabricate testimonials or endorsements, create fraudulent invoices or security alerts, or use manipulated or synthetic media to deceive people. Do not present unsupported medical, financial, or other material claims as established facts. Provide disclosures about AI-generated or manipulated content where required by law or necessary to avoid misleading recipients.

## Brands, Copyright, and Remix

You must own the necessary rights, have authorization, or otherwise be legally permitted to use material you upload, import, generate, remix, publish, or send. This includes logos, trademarks, photographs, GIFs, text, templates, and other brand assets.

The appearance of a brand or asset in Migma's gallery, a template, or a Remix does not by itself give you permission to use it or imply an affiliation or endorsement. AI-generated variations do not remove third-party rights. Obtain the necessary permission or replace material you are not entitled to use.

Do not impersonate a brand, falsely suggest sponsorship, conceal infringement, or redistribute material in violation of its license. These rules do not prohibit licensed uses or uses otherwise permitted by law, including applicable exceptions and limitations.

Migma has a designated copyright agent registered with the U.S. Copyright Office under reference **DMCA-1080305**. If an email, design, logo, or other material relating to you or your brand appears publicly in our gallery, Remix, previews, or shared designs, you or your authorized representative can request removal at [info@migma.ai](mailto:info@migma.ai?subject=Public%20content%20removal%20request). Include the exact Migma URLs, your relationship to the content or brand, and the reason for your request. You do not need a Migma account or a formal DMCA notice to request review of public content.

We prioritize removal requests, review them promptly, and act quickly to remove or disable public access once a request is verified and removal is appropriate. See [Registered Copyright Agent and Removal Requests](/legal/terms-of-use#registered-copyright-agent) for agent contact details and the removal process, or our [Copyright Notice & Takedown page](https://migma.ai/copyright) for formal copyright notices and counter-notices.

## Harmful and Unlawful Activity

You may not use Migma to create, promote, or facilitate:

* Phishing, credential theft, malware, malicious links, scams, or other fraud.
* Threats, targeted harassment, doxxing, hateful abuse, unlawful discrimination, violence, or physical harm.
* Child sexual exploitation, sexualized depictions of minors, or non-consensual intimate imagery, including AI-generated or manipulated material.
* Human trafficking, illegal goods or services, or regulated activities without legally required licenses, permissions, or safeguards.

Lawful education, reporting, criticism, and fiction are allowed when they do not facilitate prohibited conduct or violate others' rights.

## Personal and Confidential Information

Only upload or connect data you are authorized to use. Establish any required lawful basis, provide required notices, obtain necessary permissions, and limit personal data to what your intended use needs. Do not expose someone's private or confidential information without authorization or another valid legal basis.

Do not place passwords, API keys, payment credentials, or other secrets in prompts, public designs, or shared content. Use the intended secure authentication or integration flow for credentials. Process sensitive personal information only where the relevant feature expressly supports it and you have the required safeguards and agreements in place.

Our [Privacy Policy](/legal/privacy-policy) explains how Migma handles personal information.

## Account, Automation, and Platform Security

Authorized use of Migma's documented APIs, SDKs, CLI, MCP server, and agent integrations is permitted, subject to your access rights and applicable limits. Protect credentials and limit the permissions you grant to integrations and agents.

You may not:

* Access another customer's account, content, or data without authorization.
* Bypass authentication, billing, credit limits, rate limits, safety controls, consent requirements, or account restrictions, including through replacement accounts or integrations.
* Use unauthorized automation to scrape non-public data or extract proprietary code, system prompts, or platform internals.
* Disrupt the Services, overload infrastructure, or conduct security testing outside an authorized scope.
* Resell or white-label the Migma platform as your own product without authorization.

These restrictions do not prevent supported exports or other uses of your own content permitted under the Terms of Use.

## Enforcement and Review

We may investigate reported or suspected violations and request relevant evidence, such as recipient permission, domain authorization, or content rights. Depending on the circumstances, we may restrict sending, sharing, integrations, or access; remove content; or suspend or terminate accounts, consistent with our Terms and applicable law.

For serious or repeated violations, or where necessary to address an immediate risk, we may act without advance warning. We terminate accounts of repeat copyright infringers in appropriate circumstances. We will provide any notices or review opportunities required by applicable law.

If you believe we made a mistake, reply to the notice you received or email [info@migma.ai](mailto:info@migma.ai) with the subject **Acceptable use review**. Include your account or content identifier, the decision you want reviewed, and relevant supporting information. A review request does not automatically restore access or content. Copyright counter-notices follow the separate process on our [Copyright Notice & Takedown page](https://migma.ai/copyright).

## Reporting Abuse

You do not need a Migma account to make a report. Email [info@migma.ai](mailto:info@migma.ai) with the subject **Abuse report** and include:

* The exact page, share URL, or message identifier involved.
* A description of the issue and relevant context.
* For abusive email, the sender, date, and full message headers where possible.
* An email address where we can contact you for clarification.

Do not include passwords, payment credentials, unrelated personal information, or copies of child sexual abuse material. Use URLs or identifiers to help us locate the issue. Submit reports in good faith; do not use the reporting process to knowingly make false claims or harass others.

We may request additional information to assess a report. We handle and share report information as needed to investigate, respond, or comply with law, subject to our Privacy Policy and any applicable copyright notice process.

## Related Pages

<CardGroup>
  <Card title="Sending Rules" icon="envelope-circle-check" href="/get-started/what-you-can-send">
    Allowed and disallowed email use cases.
  </Card>

  <Card title="Terms of Use" icon="file-contract" href="/legal/terms-of-use">
    The terms governing your use of Migma.
  </Card>
</CardGroup>


# Privacy Policy
Source: https://docs.migma.ai/legal/privacy-policy

Welcome to MigmaAI ("MIGMAAI, INC.," "we," "our," or "us"). We respect your privacy and are committed to protecting your personal data.

**Effective Date: August 16, 2026**

## 1. Introduction

Welcome to MigmaAI ("MIGMAAI, INC.," "we," "our," or "us"). We respect your privacy and are committed to protecting your personal data. This Privacy Policy explains how we collect, use, disclose, and safeguard your information when you visit or use our website and services.

### Our Privacy Commitment

**Your privacy is protected.** We want to be clear about our core commitments to you:

* **We do not sell your personal data.** Your information is never sold to third parties for marketing or any other purpose.
* **Your data stays private by default.** We only share data when necessary to provide our services (like hosting providers), when required by law, or with your explicit consent.
* **You have control.** You can access, update, or delete your data at any time through your account settings.

The sections below explain the details of how we handle your information, but these commitments are the foundation of our approach to your privacy.

***

We comply with data privacy laws including the General Data Protection Regulation (GDPR) for users in the EEA, UK, and Switzerland, as well as relevant U.S. state privacy laws (such as CCPA, CPA, and CTDPA).

## 2. Data We Collect

We may collect and process the following types of information:

* **Personal Information**: Your name, email address, company name, and country when you register, join our waitlist, or communicate with us.
* **Account Information**: Profile information, login credentials, and preferences if you sign in with Google or use other authentication methods.
* **Usage Data**: Pages visited, features used, interactions, and time spent on our platform.
* **Device Information**: Browser type, IP address, device type, and operating system.
* **Cookies and Tracking Technologies**: We use cookies and similar tools to improve user experience, enable essential features, and analyze performance.

## 3. How We Use Your Data

We use your data for the following purposes:

* To operate, maintain, and improve the Services
* To personalize your experience and suggest relevant content
* To process your login and support your account activity
* To communicate updates, security alerts, and service messages
* To analyze usage trends and ensure platform stability
* To comply with applicable legal and regulatory requirements
* To enforce our Terms of Use

## 4. Google Sign-In

If you sign in using Google, we collect your name, email address, and profile picture through secure OAuth authentication. This data is used to:

* Create and authenticate your account
* Verify your identity
* Personalize the user experience
* Communicate relevant updates

Google's handling of your data is governed by their [Privacy Policy](https://policies.google.com/privacy).

## 5. Third-Party Services

We rely on third-party providers to deliver key functionalities. Your use of these services is subject to their respective privacy policies and terms:

* **Google Gemini AI** – [Terms](https://ai.google.dev/gemini-api/terms) | [Privacy](https://policies.google.com/privacy)
* **OpenAI (ChatGPT)** – [Terms](https://openai.com/policies/terms-of-use) | [Privacy](https://openai.com/policies/privacy-policy)
* **Anthropic Claude.ai** – [Terms](https://www.anthropic.com/legal/consumer-terms) | [Privacy](https://www.anthropic.com/legal/privacy)
* **Google Analytics** – [Terms](https://marketingplatform.google.com/about/analytics/terms/us/) | [Privacy](https://policies.google.com/privacy)
* **Microsoft Clarity** – [Terms](https://clarity.microsoft.com/terms) | [Privacy](https://privacy.microsoft.com/privacystatement)
* **Pexels** (stock photo search in the email editor) – [Terms](https://www.pexels.com/terms-of-service/) | [Privacy](https://www.pexels.com/privacy-policy/)
* **GIPHY** (GIF search in the email editor) – [Terms](https://support.giphy.com/hc/en-us/articles/360020027752-GIPHY-User-Terms-of-Service) | [Privacy](https://support.giphy.com/hc/en-us/articles/360032872931-GIPHY-Privacy-Policy)

These providers may collect and process your data as outlined in their policies. MigmaAI does not control or assume liability for third-party services.

### Stock Media Search and Delivery

Photo and GIF searches you run in the email editor are sent to Pexels and GIPHY **through our servers**, so the search request itself carries our address rather than yours. The images those searches return are a separate matter: result thumbnails are loaded by your browser directly from the provider's image network, so that provider may receive your IP address, user agent, and the time of the request while you browse results.

The same is true of media you insert. An inserted photo or GIF is referenced on the provider's content delivery network rather than copied to ours, so when a recipient opens your email, that recipient's device requests the image directly from Pexels or GIPHY, and the provider may receive the recipient's IP address, user agent, and the time of the request. If you would prefer your recipients' devices not to contact a third party, upload the image to your own library and use that copy instead.

### Connected AI Clients and Plugins

When you connect Migma to ChatGPT, Codex, or another MCP-compatible client, that client sends the tool inputs you approve to Migma. Migma returns only the account data or action result needed for that tool call. Depending on your request, a tool may read data or create, edit, export, validate, or send email through your Migma account.

Access is limited by the permissions shown during OAuth consent or assigned to the connected API key. You can revoke a connected client from **Settings → Developers → API Keys**. Authentication tokens are used to authorize requests and are not included in normal tool results. The connected client provider processes conversation content and tool inputs or results under its own terms and privacy policy.

## 6. Data Sharing and Disclosure

We may share your information with:

* **Service Providers** who perform hosting, analytics, authentication, or other operational services
* **Legal Authorities** if required to comply with applicable law or respond to valid requests
* **Business Transfers** in connection with mergers, acquisitions, or asset sales
* **With Your Consent** when you authorize us to do so

We do not sell your personal data to third parties.

## 7. Data Storage and International Transfers

Your data is stored securely in the United States. By using our Services, you consent to the transfer and processing of your data in the U.S., which may not offer the same level of protection as your home jurisdiction.

We implement safeguards to comply with GDPR and other applicable data protection laws.

## 8. Data Security

We apply industry-standard security measures (e.g., HTTPS, encryption, access controls) to protect your information. However, no method of electronic storage or transmission is completely secure.

## 9. Your Privacy Rights

Depending on your jurisdiction (e.g., EU, UK, California, Colorado), you may have the right to:

* Access your data
* Correct inaccurate data
* Request deletion of your data
* Withdraw consent at any time
* Restrict or object to data processing
* Export your data in a machine-readable format
* Lodge a complaint with your local data protection authority

You may exercise these rights through your profile settings or by emailing us at [info@migma.ai](mailto:info@migma.ai).

## 10. Cookies and Consent Management

We use cookies to operate the platform, personalize content, and analyze traffic. For users in the EEA, UK, and certain U.S. states:

* You will be prompted to provide consent before non-essential cookies are set
* You may manage your preferences via our cookie banner or settings page
* We comply with the ePrivacy Directive and US state laws related to cookies and data tracking

## 11. Account Deletion and Data Removal

You may delete your account and personal data at any time via the profile settings. Upon deletion, we erase your data unless retention is required by law.

## 12. Changes to This Privacy Policy

We may update this Privacy Policy periodically. We will notify you by updating the "Effective Date" at the top of this page. Your continued use of our Services means you accept any changes.

## 13. Contact Us

If you have any questions or wish to exercise your privacy rights, please contact:

**MIGMAAI, INC.**\
131 Continental Dr, Suite 305\
Newark, Delaware 19713\
Email: [info@migma.ai](mailto:info@migma.ai)


# Terms of Use
Source: https://docs.migma.ai/legal/terms-of-use

Read the binding Terms of Use for MigmaAI services, including account responsibilities, acceptable use, subscriptions, intellectual property, and liability.

**Effective Date: September 12, 2026**

Welcome to MigmaAI! These Terms of Use ("Terms") govern your access to and use of MigmaAI's services, including our website ([https://migma.ai](https://migma.ai)), applications, and tools powered by artificial intelligence and analytics (collectively, the "Services"). These Services are provided by MIGMAAI, INC., a Delaware corporation registered via Stripe in the United States.

By using our Services, you agree to comply with these Terms and our [Acceptable Use Policy](/legal/acceptable-use), which forms part of these Terms. Our [Privacy Policy](/legal/privacy-policy) explains how we handle personal information. Your use of third-party services is also subject to their applicable terms and privacy policies, outlined in Section 4.

## 1. Acceptance of Terms

By accessing or using our Services, you agree to be bound by these Terms. If you do not agree, do not use the Services. We may revise these Terms from time to time. The "Effective Date" at the top reflects the latest version. Continued use signifies your acceptance of any updates.

## 2. Description of Services

MigmaAI enables users to create professional, personalized emails using AI technology. The platform integrates third-party models from:

* Google Gemini
* OpenAI's ChatGPT
* Anthropic's Claude.ai

We also use analytics services to improve performance and security. These features may change without notice.

## 3. Eligibility & Account Creation

You must be at least 18 years old to use our Services. By registering, you agree to:

* Provide accurate and complete information
* Maintain the confidentiality of your login credentials
* Notify us of unauthorized access
* Accept full responsibility for activity under your account

You may delete your account and associated data via your profile settings at any time.

## 4. Google Sign-In and Third-Party Integration

If you use Google Sign-In, you authorize us to access basic profile information (e.g., name, email, profile picture) in accordance with:

* [Google Privacy Policy](https://policies.google.com/privacy)
* [Google Terms of Service](https://policies.google.com/terms)

We do not use this data for advertising or sell it to third parties.

We also use:

* Google Gemini ([Terms](https://ai.google.dev/gemini-api/terms), [Privacy](https://policies.google.com/privacy))
* OpenAI (ChatGPT) ([Terms](https://openai.com/policies/terms-of-use), [Privacy](https://openai.com/policies/privacy-policy))
* Anthropic Claude ([Terms](https://www.anthropic.com/legal/consumer-terms), [Privacy](https://www.anthropic.com/legal/privacy))
* Google Analytics ([Terms](https://marketingplatform.google.com/about/analytics/terms/us/), [Privacy](https://policies.google.com/privacy))
* Microsoft Clarity ([Terms](https://clarity.microsoft.com/terms), [Privacy](https://privacy.microsoft.com/privacystatement))
* Pexels — stock photo search in the email editor ([Terms](https://www.pexels.com/terms-of-service/), [License](https://www.pexels.com/license/), [Privacy](https://www.pexels.com/privacy-policy/))
* GIPHY — GIF search in the email editor ([Terms](https://support.giphy.com/hc/en-us/articles/360020027752-GIPHY-User-Terms-of-Service), [Privacy](https://support.giphy.com/hc/en-us/articles/360032872931-GIPHY-Privacy-Policy))

Your use of these services is subject to their respective terms and policies.

## 5. Data Storage and Regulatory Compliance

All user data is stored securely in the United States. MigmaAI complies with:

* GDPR (General Data Protection Regulation) for users in the EEA, UK, and Switzerland
* US state-level privacy laws, including CCPA (California), CPA (Colorado), CTDPA (Connecticut), and others

We:

* Obtain explicit consent before collecting or processing personal data
* Allow users to withdraw consent or delete their accounts via profile settings
* Provide cookie banners and customizable privacy preferences to meet legal requirements
* Allow ad-serving configurations only after appropriate consent in the EU/UK/CH

## 6. User Content

You retain ownership of content you upload but grant us a non-exclusive, royalty-free, global license to use it for service delivery and improvement.

You may not:

* Violate any laws or third-party rights
* Harass, impersonate, or deceive others
* Upload viruses or malicious scripts
* Use automated tools without authorization, exceed granted permissions, bypass security or usage controls, or scrape non-public data

Authorized use of our documented APIs, SDKs, CLI, MCP server, and agent integrations is permitted subject to these Terms and the [Acceptable Use Policy](/legal/acceptable-use).

The Acceptable Use Policy contains additional rules for email, AI-generated content, brand and content rights, platform security, reporting, and review of enforcement decisions. We may restrict access, remove content, or suspend or terminate accounts for violations as described in that policy and these Terms.

### Stock Photos and GIFs

The email editor lets you search and insert media from third-party libraries. MigmaAI does not own this media and grants you no rights in it; each item is licensed by its provider, and you are responsible for your use of anything you insert.

**Photos (Pexels).** Photos are provided under the [Pexels License](https://www.pexels.com/license/), which permits free use — including commercial use — with no attribution required, and permits editing. The Pexels License does place limits on that use, including that you may not sell unaltered copies, imply that a person or brand shown endorses your product, redistribute the media on another stock platform, use it as part of a trademark or business name, or show identifiable people in an offensive light. Crediting the photographer is optional and always appreciated.

**GIFs (GIPHY).** GIFs are supplied by GIPHY and are largely uploaded by third parties. They frequently contain material owned by others — film and television clips, characters, logos and other brand assets — and the rights attached to any individual GIF vary. GIPHY's terms permit sharing GIFs through integrations such as ours; they do not grant you a license to use third-party content in advertising or other commercial messaging. Before sending a GIF in a commercial campaign, satisfy yourself that you have the rights you need, or choose media you own or have licensed.

Because inserted media is loaded from the provider's own servers when your email is opened, it may become unavailable if the provider removes it. Media that must remain available indefinitely should be uploaded to your own library instead.

## 7. Intellectual Property

All intellectual property in the Services (excluding User Content) belongs to MigmaAI or its licensors. You may not copy, reproduce, distribute, modify, or reverse engineer any part of our platform without written permission.

## 8. Payment Terms

We may offer paid services. By subscribing, you agree to:

* Pay all applicable fees
* Understand that all payments are non-refundable unless stated otherwise
* Accept that pricing may change with advance notice via website or email

## 9. No Warranty

THE SERVICES ARE PROVIDED "AS IS" AND "AS AVAILABLE."

We disclaim all warranties, express or implied, including:

* Merchantability
* Fitness for a particular purpose
* Non-infringement
* Accuracy or reliability of third-party AI results

We do not guarantee error-free or uninterrupted service.

## 10. Limitation of Liability

To the maximum extent allowed by law, MigmaAI and its affiliates are not liable for:

* Indirect, incidental, or consequential damages
* Loss of profits or data
* Any claims exceeding \$50 USD

## 11. Dispute Resolution

### 11.1 Informal Resolution

Before initiating legal proceedings, please contact us at [info@migma.ai](mailto:info@migma.ai) for a good-faith resolution.

### 11.2 Binding Arbitration

If unresolved, disputes shall be resolved through binding arbitration (JAMS). You waive your rights to:

* Jury trial
* Class actions

You may opt out within 30 days of first use by emailing [info@migma.ai](mailto:info@migma.ai).

## 12. Copyright & DMCA Policy

### Registered Copyright Agent

Migma has a designated copyright agent registered with the U.S. Copyright Office. The designation reference is **DMCA-1080305**, filed under **MigmaAl, Inc.** Our designated agent's contact details are:

**Copyright Agent**\
MigmaAl, Inc.\
131 Continental Dr\
Newark, DE 19731, United States\
Phone: [(351) 222-2440](tel:+13512222440)\
Email: [info@migma.ai](mailto:info@migma.ai)

### Request Removal of Public Content

If you find an email, design, logo, or other material relating to you or your brand displayed publicly on Migma, you or your authorized representative can request its removal. This includes our email gallery, Remix, public previews, and shared designs. You do not need a Migma account to submit a request.

Email [info@migma.ai](mailto:info@migma.ai?subject=Public%20content%20removal%20request) with the subject **Public content removal request** and include:

* Your name, contact email, and relationship to the person, brand, or rights holder concerned.
* The exact Migma URLs of the emails, designs, images, or brand pages you want removed.
* A short explanation of your concern and the action you are requesting.
* Any supporting information that helps us confirm your authority or identify the material.

We prioritize these requests and review them promptly. Once we have verified the request and determined that removal is appropriate, we will act quickly to remove the material or disable public access on Migma. We may ask for missing details to locate the content or confirm the request.

### Copyright Notices and Other Rights Requests

You can request review of public email, brand, or trademark content without submitting a formal DMCA notice. Trademark and other brand concerns are reviewed separately from copyright infringement claims.

For a formal copyright infringement notice, use the notice requirements on our [Copyright Notice & Takedown page](https://migma.ai/copyright#copyright-notices). We respond expeditiously to valid copyright notices, including by removing or disabling access to the identified material where appropriate, and terminate accounts of repeat copyright infringers in appropriate circumstances.

Our [Copyright Notice & Takedown page](https://migma.ai/copyright) also explains how reports are handled and how someone whose content was removed can submit a counter-notice or request review. Report information is handled according to that policy and our [Privacy Policy](/legal/privacy-policy).

## 13. Intellectual Property Protection & Enforcement

### Trade Secrets

You acknowledge that MigmaAI's AI models, system prompts, training data, email compiler, algorithms, and proprietary methodologies constitute valuable trade secrets. Unauthorized access, copying, or disclosure constitutes misappropriation under the Defend Trade Secrets Act (18 U.S.C. § 1836) and applicable state laws.

### Acknowledgment of Harm

You agree that any breach of Sections 5 or 6 will cause irreparable harm to MigmaAI that cannot be adequately compensated by monetary damages alone.

### Remedies

In addition to account suspension, MigmaAI reserves the right to:

* Seek immediate injunctive relief without posting bond
* Pursue actual damages, statutory damages, and disgorgement of profits
* Recover reasonable attorney's fees and litigation costs
* Report violations to law enforcement where applicable

### Audit Rights

MigmaAI may audit usage logs to investigate suspected violations. Continued use constitutes consent to such audits.

### Jurisdiction

Any disputes shall be resolved exclusively in state or federal courts located in Delaware. You waive objections to personal jurisdiction and venue.

### Survival

These IP protection provisions survive termination of your account.

## 14. Termination and Account Deletion

You may delete your account anytime from your profile. We may also suspend or terminate your account for violations of these Terms or the [Acceptable Use Policy](/legal/acceptable-use), subject to applicable law. The Acceptable Use Policy explains how to request review of an enforcement decision. Upon termination, your data will be deleted except as required by law.

## 15. Export Compliance

You may not use the Services in violation of U.S. export laws or in any country embargoed by the U.S. government.

## 16. Third-Party Links

Our platform may contain links to third-party websites. We are not responsible for their content, availability, or practices. Use them at your own discretion.

## 17. Contact Information

For any questions regarding these Terms:

**MIGMAAI, INC.**\
131 Continental Dr, Suite 305\
Newark, Delaware 19713\
Email: [info@migma.ai](mailto:info@migma.ai)


# Connect AI Agents with the Migma MCP Server
Source: https://docs.migma.ai/mcp-server

Connect MCP-compatible editors and agents to Migma through a remote or local server, configure authentication, verify tools, and control action scopes.

Migma MCP lets agents work with your Migma brands from an editor or agent client. Agents can prepare emails, fetch email IDs, validate output, create campaign drafts, send tests, export approved emails, manage contacts, and inspect results.

For Grok Bot desktop, follow the [Grok Bot connection guide](/grok) to connect Migma, approve access in your browser, and verify your brand with a read-only request.

<Info>
  Remote MCP is available at `https://migma.ai/mcp` over Streamable HTTP. Add this URL. Your client opens Migma so you can sign in, approve access, and complete credential exchange through OAuth.
</Info>

## Where this lives in Migma

Open **My Brands**, choose a brand, then open **Tools**. The app `/mcp` route redirects to the active brand's Tools page.

OAuth and CLI keys appear in **Settings → Developers → API Keys**, where you can revoke them.

## Choose connection type

| Type | Use when | Config |
| - | - | - |
| Remote MCP | Client supports hosted MCP | `url: https://migma.ai/mcp` |
| Local MCP | Client only supports command-based MCP servers | `npx -y @migma/mcp` |

## Remote MCP

### Tool profiles

`https://migma.ai/mcp` provides the OpenAI profile: email and brand workflows,
contacts, sending-domain setup, existing domain history, and account credit reads.
It excludes domain shopping and subscription checkout.

For domain shopping or subscription management in a general MCP client, connect
with `https://migma.ai/mcp?profile=general`. Local MCP also provides these tools.
Both hosted profiles use the same OAuth flow and permission checks. Refresh your
client's tool list after changing its URL.

### Recommended: OAuth connector setup

Use this path for clients that support OAuth connection, such as claude.ai custom connectors.

1. Add Migma as a custom connector with `https://migma.ai/mcp`.
2. Follow the client sign-in flow. It opens Migma so you can review and approve access.
3. On `migma.ai/connect/authorize`, check the app name, return host, and requested scopes. `email:send` permits test/direct sends. `campaign:write` permits campaign creation, send, and schedule. Migma marks both as delivery access.
4. Approve the connection. Migma gives the client a scoped API key automatically, so there is no key to copy or paste.

OAuth-created keys appear in **Settings → Developers → API Keys** and can be revoked there.

### Claim-code fallback

If a direct client cannot complete an OAuth redirect/callback, fetch `https://api.migma.ai/auth.md`. The agent shows a claim link, you review and approve scopes in Migma, and the agent polls for its credential.

Use claim-code only when the direct client can keep `claim_token` and the returned credential out of chat, logs, shell history, and shared files. It does not repair a hosted connector whose OAuth callback failed.

Do not send an interactive user to Settings to copy a key.

### CI and server automation

Manual bearer configuration remains available for CI, cron, or server automation:

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "url": "https://migma.ai/mcp",
      "headers": {
        "Authorization": "Bearer your_migma_api_key"
      }
    }
  }
}
```

Do not put API keys in URLs. Send them through the documented authorization header.

## Local MCP

Local MCP is available with `npx -y @migma/mcp`. Use it only when the client requires a command-based server. Run `migma login` first (the package reads `~/.migma/config.json`), or set `MIGMA_API_KEY` for CI.

```json theme={null}
{
  "mcpServers": {
    "migma": {
      "command": "npx",
      "args": ["-y", "@migma/mcp"],
      "env": {
        "MIGMA_API_KEY": "your_migma_api_key"
      }
    }
  }
}
```

Optional environment variable:

```bash theme={null}
export MIGMA_PROJECT_ID=proj_abc123
```

Use `MIGMA_PROJECT_ID` only for Local MCP when one brand is the default. Remote MCP clients should call `migma_list_projects` and pass `projectId`.

Remote MCP clients discover brands with `migma_list_projects`, then pass `projectId`.

For Claude CLI, add the local server with:

```bash theme={null}
claude mcp add --scope user migma -- npx -y @migma/mcp
claude mcp list
claude mcp get migma
claude mcp remove migma
```

## Client setup

<CardGroup>
  <Card title="Cursor" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/cursor.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=1bc8ebb9727a9e7b6671d0c5a7dae482" href="/agents/mcp-cursor">
    Add Migma MCP to Cursor.
  </Card>

  <Card title="Claude" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/agents/mcp-claude">
    Connect Claude.ai, Claude Code, or Claude Desktop. Visual setup: [Claude tutorial](/tutorials/connect-migma-to-claude-code).
  </Card>

  <Card title="ChatGPT" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/agents/mcp-chatgpt">
    Use the public Migma plugin. Visual setup: [ChatGPT tutorial](/tutorials/connect-migma-to-chatgpt).
  </Card>

  <Card title="Grok" icon="https://mintcdn.com/migmaai/D0Z-B44phiLBOsYh/images/logos/grok-bot.webp?fit=max&auto=format&n=D0Z-B44phiLBOsYh&q=85&s=3154724e3ec13fdf760e0b3cc4225509" href="/grok">
    Ask Grok Bot to add Migma Remote MCP, or connect Grok web and Grok Build directly.
  </Card>

  <Card title="Copilot" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/copilot.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=a1ae89d7f530a9604e469be973f465d4" href="/agents/mcp-copilot">
    Connect GitHub Copilot to Migma MCP.
  </Card>

  <Card title="Codex CLI" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/codex.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=a4b7a9b1b86045262a76ff6dd3067637" href="/agents/mcp-codex">
    Add Migma MCP to Codex CLI.
  </Card>

  <Card title="Windsurf" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/windsurf.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=ebbece28d09dcab4e8a49b58e80e243c" href="/agents/mcp-windsurf">
    Connect Migma MCP to Windsurf.
  </Card>

  <Card title="Antigravity" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/antigravity.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=db40bf15f23a3195738b84f99c1b2148" href="/agents/mcp-antigravity">
    Add Migma MCP to Google Antigravity.
  </Card>

  <Card title="Raycast" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/raycast.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=0517327673bc3a44f7e48532e8fc00f0" href="/agents/mcp-raycast">
    Use Migma MCP from Raycast AI.
  </Card>

  <Card title="VS Code" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/vscode.svg?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=a33b2611b16ff0ff7f6a02f6d54c07b8" href="/agents/mcp-vscode">
    Connect Migma MCP to VS Code.
  </Card>
</CardGroup>

## Verify the connection

Ask your client to show your Migma context. `migma_get_context` returns your workspaces, brands, plan and credits, sending domains, and suggested next actions in one call — pass a workspace id as `organizationId` to `migma_list_projects` to work in another workspace.

Agents can still use `migma_get_capabilities` on their own when they need the tool catalog, write/read rules, or guided workflows.

## Common workflows

### Design emails (show drafts first)

1. Reuse the working brand and supplied brief or reference. List brands and choose `projectId` only when needed; ask only for missing required details. Audience and sending-domain setup are not needed for drafts.
2. For researched work, build an exact source-backed fact checklist. Pass required facts in the prompt and up to five public HTTPS source-image URLs through structured `images`; prompt-only URLs are not image inputs.
3. Create or design with one `migma_generate_email` call (load that tool by exact name). For several emails pass `count` (max 12) and name each email's job in the prompt. Do not call generate once per email. Then poll `migma_get_generation_status`. Existing HTML or `.eml` uses `migma_import_html` instead of generate.
4. Show returned preview images and each canvas link immediately.
5. After first show, verify every required fact and source image before claiming success. If a preview cannot be attached, show its canvas link and say visual verification is incomplete.
6. After the first preview, handle requested edits, inbox checks, or campaign setup. Do not run validate or edit tools before that first show. Text-only edit cannot add structured source images; that requires replacement generation.
7. Run `migma_validate_*` when the user asks for checks, or as a last step before send.

### Edit an email

`migma_edit_email` starts a queued edit and returns its IDs and status promptly. It keeps the existing `emailId`, `prompt`, `label`, and `includeHtml` arguments, and adds optional `idempotency_key`. The tool requires both `email:write` and `email:read`. `includeHtml` on the start call reminds the agent to request HTML on the subsequent status call; it does not make the start call wait.

<Note>
  These queued-edit tools require an MCP build that includes them. If they are missing after refreshing the client's tool list, use the REST API: `POST /v1/emails/{emailId}/edit` with `async: true` and a stable `Idempotency-Key`, then poll `GET /v1/emails/{emailId}/edits/{editId}`.
</Note>

1. Call `migma_edit_email` once with the target `emailId` and prompt. Keep the same `idempotency_key` if the start result is uncertain.
2. Poll the read-only `migma_get_email_edit_status` tool with `emailId`, `editId`, and optional `includeHtml`.
3. Use that tool's exact job status. Do not use conversation generation status to decide that the edit finished; a previous conversation turn may already be completed.
4. Never resubmit an edit while it is pending or processing. On failure, inspect the stored email before starting another edit because changes may have been saved.
5. When the status is completed, show the returned preview.

The edit worker does not automatically retry the rewrite after a failure or stall. Total time depends on section and image complexity, provider behavior, and retries; there is no fixed maximum edit latency.

### Convert existing HTML

1. List brands and choose `projectId`.
2. Call `migma_import_html` once with the HTML or `.eml` source (or `htmls` for several files). Optional instruction: keep it as-is, or apply the brand.
3. Poll `migma_get_generation_status`, then show preview images and each canvas link.
4. Each result is one canvas slot with its own `emailId`. Edit, send, and export use that id.

### Save brand facts

* Call `migma_add_knowledge_base` when the user shares lasting facts (tone, products, offers, policies). Do not list first.

### Favorite an email for future designs

When the user says "I like this design," "favorite this email," or "save this style," call `migma_save_reference` with the exact email they chose:

```json theme={null}
{ "emailId": "<chosen emailId>" }
```

Use the ID already returned by generation status or `migma_list_emails` for the working brand. For a series, choose one slot's `emailId`, not `conversationId`. Ask which email only when unclear. No HTML fetch, re-import, or duplicate knowledge-base entry is needed.

The tool requires `project:write` and sets the favorite to true. Retrying that same `emailId` is safe. Confirm only after the response contains `favorite: true`. Future generation for the same brand uses saved references by default unless disabled, and later saved edits to the favorite update the reference. A favorite is design guidance; current facts and send approval remain separate.

For an external email, the same tool accepts `projectId` + `title` + `html`, with an optional `screenshotUrl`. This creates a reference entry, so it does not share the favorite mode's safe-repeat behavior. A screenshot alone cannot be saved through this tool. Check `migma_get_capabilities` if the tool is missing; it may require `project:write` access or refreshing the client's cached tools.

### Import a CSV audience

* Call `migma_create_contact_import` once with the full CSV text and an optional list tag.
* Leave column mapping empty when headers look like email, first name, or last name.
* Prefer this over converting CSV rows into a JSON bulk import.
* The import can wait and return final counts in the same turn.

### Import from Klaviyo, Mailchimp, or HubSpot

* Call `migma_list_provider_import_sources` with the brand and provider to list audiences, lists, segments, and tags.
* Call `migma_import_contacts_from_provider` with one to 25 sources and an optional `consentMode` (`subscribed-only` by default).
* The tool can wait up to 45 seconds, then poll `migma_get_contact_import` for final counts, tag and segment IDs, and `non_sendable` contacts.

### Export unsubscribers and reconcile a connected store

These workflows require a server release with the tools below. If tools are missing, refresh the client's catalog and check granted scopes. Connected-store tools are available in the **general** profile (`?profile=general`).

1. Choose the brand, then call `migma_create_contact_export` with `filters: {status: "unsubscribed"}` and a stable `idempotency_key`. Optional saved segment and grouped filters narrow the audience. This requires `audience:read`.
2. Poll `migma_get_contact_export` with the returned `jobId` and `projectId`. Only `completed` includes a private CSV download URL and actual exported count. Queued work is not a finished export; failure is not an empty audience.
3. The URL expires in one hour. Poll the same job for a fresh URL while it is retained, up to seven days. Retrying creation with the same key and body finds the same job.
4. To inspect a connected store or CRM, use `migma_list_connected_tools`, then `migma_get_connected_tool` for the exact argument schema. Discovery requires `email:read`; execution requires `project:write`.
5. Obtain approval for the concrete external changes before `migma_call_connected_tool`. Existing enabled-tool grants and approval settings remain enforced. A tool requiring interactive dashboard approval remains blocked here; review its permissions in the brand's MCP Servers settings.

Exporting does not update Shopify. The default Shopify storefront connection exposes catalog and cart tools, not customer marketing-consent updates. Synchronization needs a connected tool with customer consent-write access. Verify provider results and partial failures before reporting success; never resubscribe exported unsubscribers or automatically retry an unknown write outcome.

### Out of credits

* On an out-of-credits error, call `migma_get_credits` and explain the limit briefly. Existing drafts and tasks that use no credits can continue.
* In the general profile or local MCP, use `migma_get_upgrade_link` when the user asks to manage billing or accepts a relevant billing offer. New subscribers choose a plan before receiving a checkout link. Existing subscribers omit `plan` to review changes in the billing portal.
* Passing `plan` for an existing subscription can change it and charge a prorated payment immediately. Obtain explicit approval for that charge first.
* Show the returned URL once and check updated credits before resuming blocked work. A link alone does not confirm payment. This tool is absent from the OpenAI profile.

### Buy a domain

Use the general hosted profile or local MCP for domain shopping.

1. Search availability and yearly prices with `migma_search_buyable_domains`.
2. Call `migma_buy_domain` and show the returned checkout URL. The user pays in the browser. A free account can hold one purchased domain; account eligibility and current annual pricing are checked before checkout. The domain purchase renews annually.
3. Poll `migma_get_domain_purchases` until the domain is active.
4. Set it up for sending with `migma_setup_domain`. When DNS is still required, `migma_setup_domain` and `migma_verify_domain` return a `connectUrl` that opens one-click DNS setup in Migma.

### Other

* Open the email in Migma from the returned canvas link
* Fetch exact `emailId` values
* Send a test email (ask before any live send)
* Create a campaign draft
* Export approved email to HTML, PNG, PDF, Klaviyo, Mailchimp, or HubSpot
* Read campaign metrics and logs
* Manage contacts, lists, segments, and sending domains
* Check the plan and remaining credits (`migma_get_credits`); subscription management (`migma_get_upgrade_link`) is available in the general profile or local MCP
* Track existing domains (`migma_get_domain_purchases`); domain search and checkout (`migma_search_buyable_domains`, `migma_buy_domain`) are available in the general profile or local MCP, with payment in the user's browser
* Manage DNS records on domains bought in Migma (`migma_list_dns_records`, `migma_add_dns_record`, `migma_remove_dns_record`): add A, AAAA, CNAME, MX, TXT, or NS records like Google Workspace MX or a site-verification TXT, and remove user-added records. Migma's email sending records are protected, and the root and www names are reserved for domain forwarding

## Security

IT and security reviewers: [Review Migma MCP](/security/mcp) covers what the hosted server can do, how OAuth works, permissions including `email:send`, and how to revoke access.

* Prefer OAuth connection for clients that support it.
* Use scoped API keys.
* Review scopes before approval. `email:send` allows test/direct sends. `campaign:write` allows campaign creation, send, and schedule. Only allow either when you trust the connector to deliver mail.
* Revoke OAuth-created and manually created keys from **Settings → Developers → API Keys**.
* Keep human approval enabled before sends, exports, audience changes, and campaign changes.
* Send API keys through the documented authorization header.
* Treat MCP like direct API access. Tool calls use the same Migma permissions as SDK, CLI, and REST API requests.

## Troubleshooting

| Symptom | Fix |
| - | - |
| OAuth consent does not open or callback is rejected | Do not paste a Settings key. Use `auth.md` claim-code only for a direct client with secure credential storage, or use Local MCP after `migma login`. |
| `Missing Bearer token` | Finish OAuth, reconnect, or use the `auth.md` claim-code fallback for a direct client. Manual bearer setup is for CI/server automation. |
| Client cannot send headers | Use Local MCP with `npx -y @migma/mcp`. |
| `projectId is required` | Call `migma_list_projects`, then pass `projectId`. |
| Queued edit appears stuck | Poll `migma_get_email_edit_status` with its `editId`. Do not resubmit a pending edit or rely on conversation generation status. |
| Tool list looks stale | Restart the client or reset cached MCP tools. |

## Resources

<CardGroup>
  <Card title="MCP for IT admins" icon="shield-check" href="/security/mcp">
    What the hosted server can do, permissions, and how to revoke access.
  </Card>

  <Card title="npm Package" icon="cube" href="https://www.npmjs.com/package/@migma/mcp">
    Local MCP package.
  </Card>

  <Card title="Agent Registration" icon="key" href="/agent-registration">
    Let agents request scoped access.
  </Card>
</CardGroup>


# Automate Migma with n8n
Source: https://docs.migma.ai/n8n

Automate your email workflows using Migma and n8n. Import brands from websites and generate AI-powered emails using simple drag-and-drop nodes.

## Overview

Automate your email workflows using Migma and [n8n](https://n8n.io). Import brands from websites and generate AI-powered emails using simple drag-and-drop nodes.

<Info>
  **What is n8n?** An open-source workflow automation tool with a visual interface. Perfect for connecting APIs without writing code.
</Info>

## Quick Setup

<Steps>
  <Step title="Get Your API Key">
    Go to [Migma Settings → Developers → API Keys](https://migma.ai/settings?tab=api-keys) and create an API key
  </Step>

  <Step title="Add Credentials in n8n">
    In n8n: **Settings → Credentials → Add Credential → Http Bearer Auth**

    Paste your API key and name it "Migma API"
  </Step>
</Steps>

## Key Endpoints

All endpoints use `https://api.migma.ai` as the base URL.

| Endpoint | Method | Description |
| - | - | - |
| `/v1/projects/import` | POST | Import a brand from website URL |
| `/v1/projects/import/{projectId}/status` | GET | Check import status |
| `/v1/projects/{projectId}` | GET | Get project details |
| `/v1/projects/emails/generate` | POST | Generate an email |
| `/v1/projects/emails/{conversationId}/status` | GET | Check generation status |
| `/v1/export/html/{conversationId}` | GET | Export as HTML |
| `/v1/export/png/{conversationId}` | GET | Export as PNG |
| `/v1/emails/test/send` | POST | Send test email |

<Card title="Full API Reference" icon="book" href="/api-reference/introduction">
  View complete documentation with all parameters and responses
</Card>

## Copy-Paste Workflows

### 1. Import a Brand

Import brand assets from a website URL.

<Accordion title="Import Brand Workflow JSON">
  ```json theme={null}
  {
    "name": "Migma: Import Brand",
    "nodes": [
      {
        "parameters": {},
        "id": "manual-trigger",
        "name": "Start",
        "type": "n8n-nodes-base.manualTrigger",
        "typeVersion": 1,
        "position": [250, 300]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/projects/import",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"urls\": [\"https://yourwebsite.com\"]}",
          "options": {}
        },
        "id": "import-brand",
        "name": "Import Brand",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [450, 300],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      }
    ],
    "connections": {
      "Start": {
        "main": [[{ "node": "Import Brand", "type": "main", "index": 0 }]]
      }
    }
  }
  ```
</Accordion>

**What you get back:**

* `projectId`: Use this to check status
* `status`: Will be "pending" initially
* `domain`: Extracted domain name

### 2. Generate an Email

Generate an AI-powered email for a project.

<Accordion title="Generate Email Workflow JSON">
  ```json theme={null}
  {
    "name": "Migma: Generate Email",
    "nodes": [
      {
        "parameters": {},
        "id": "manual-trigger",
        "name": "Start",
        "type": "n8n-nodes-base.manualTrigger",
        "typeVersion": 1,
        "position": [250, 300]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/projects/emails/generate",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"projectId\": \"YOUR_PROJECT_ID\", \"prompt\": \"Create a welcome email for new subscribers\"}",
          "options": {}
        },
        "id": "generate-email",
        "name": "Generate Email",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [450, 300],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      }
    ],
    "connections": {
      "Start": {
        "main": [[{ "node": "Generate Email", "type": "main", "index": 0 }]]
      }
    }
  }
  ```
</Accordion>

**What you get back:**

* `conversationId`: Use this to check status and export
* `status`: Will be "pending" initially
* `link`: Direct link to view in Migma dashboard

### 3. Export as HTML

Export the generated email as HTML.

<Accordion title="Export HTML Workflow JSON">
  ```json theme={null}
  {
    "name": "Migma: Export HTML",
    "nodes": [
      {
        "parameters": {},
        "id": "manual-trigger",
        "name": "Start",
        "type": "n8n-nodes-base.manualTrigger",
        "typeVersion": 1,
        "position": [250, 300]
      },
      {
        "parameters": {
          "method": "GET",
          "url": "=https://api.migma.ai/v1/export/html/YOUR_CONVERSATION_ID",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "options": {}
        },
        "id": "export-html",
        "name": "Export HTML",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [450, 300],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      }
    ],
    "connections": {
      "Start": {
        "main": [[{ "node": "Export HTML", "type": "main", "index": 0 }]]
      }
    }
  }
  ```
</Accordion>

**What you get back:**

* `files[0].content`: Full HTML content as string
* `files[0].url`: Download URL (valid for 24 hours)
* `files[0].fileSize`: Size in bytes

<Tip>
  Replace `YOUR_CREDENTIAL_ID`, `YOUR_PROJECT_ID`, and `YOUR_CONVERSATION_ID` with your actual values, or use n8n expressions like `{{ $json.data.projectId }}` to pass data between nodes.
</Tip>

## Complete Workflow

Here's a full workflow that imports a brand, waits for completion, generates an email, and exports it:

<Accordion title="Complete Workflow JSON">
  ```json theme={null}
  {
    "name": "Migma: Complete Workflow",
    "nodes": [
      {
        "parameters": {
          "documentId": {
            "__rl": true,
            "value": "1uS3X18r5pqrcZK6iHMI6StQtBaLAZvpavrUhahv_bTE",
            "mode": "list",
            "cachedResultName": "Migma Leads v1",
            "cachedResultUrl": ""
          },
          "sheetName": {
            "__rl": true,
            "value": 1667714778,
            "mode": "list",
            "cachedResultName": "Sheet01",
            "cachedResultUrl": ""
          },
          "options": {}
        },
        "id": "df5ca5e4-3224-42bd-a593-eecfeceaf60f",
        "name": "Read Stores",
        "type": "n8n-nodes-base.googleSheets",
        "typeVersion": 3,
        "position": [
          -1760,
          352
        ]
      },
      {
        "parameters": {
          "options": {}
        },
        "id": "a83ab73f-b6cd-4882-970f-983c93d7b10a",
        "name": "Loop Stores",
        "type": "n8n-nodes-base.splitInBatches",
        "typeVersion": 3,
        "position": [
          -1552,
          352
        ]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/projects/import",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"urls\": [\"{{ $json['Store URL'] }}\"]}",
          "options": {}
        },
        "id": "2a72b8c9-76fd-4ee2-aee6-a9627e6f8a2c",
        "name": "Import Store",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [
          -1360,
          352
        ],
        "credentials": {
          "httpBearerAuth": {
            "id": "StqUFSi6OmezZlVH",
            "name": "Bearer Auth account"
          }
        }
      },
      {
        "parameters": {
          "amount": 5,
          "unit": "seconds"
        },
        "id": "94310ed1-811c-480a-81cd-50c0b4d3d2d2",
        "name": "Wait",
        "type": "n8n-nodes-base.wait",
        "typeVersion": 1,
        "position": [
          -192,
          560
        ],
        "webhookId": "wait-webhook-gen"
      },
      {
        "parameters": {
          "conditions": {
            "string": [
              {
                "value1": "={{ $json.data.status }}",
                "operation": "equals",
                "value2": "completed"
              }
            ]
          }
        },
        "id": "55ff368a-5dee-479d-aecf-c6f78c7807e4",
        "name": "Is Ready?",
        "type": "n8n-nodes-base.if",
        "typeVersion": 1,
        "position": [
          32,
          560
        ]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/shopify/connect",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"projectId\": \"{{ $json.data.projectId }}\", \"shopifyStoreUrl\": \"{{ $('Loop Stores').item.json['Store URL'] }}\"}",
          "options": {}
        },
        "id": "b5f28477-5b11-49c7-a6c0-51a6605c6a60",
        "name": "Connect Shopify",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [
          -784,
          128
        ]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/projects/emails/generate",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"projectId\": \"{{ $json.data.projectId }}\", \"prompt\": \"Create a welcome email\", \"webMode\": true}",
          "options": {}
        },
        "id": "db9b18ac-e681-4771-890b-a7516d89aaf2",
        "name": "Generate Email",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [
          -384,
          64
        ]
      },
      {
        "parameters": {
          "url": "=https://api.migma.ai/v1/projects/emails/{{ $json.data.conversationId }}/status",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "options": {}
        },
        "id": "43a7fc19-604f-48a8-b01b-b564d01db916",
        "name": "Check Generation",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [
          -176,
          48
        ],
        "credentials": {
          "httpBearerAuth": {
            "id": "StqUFSi6OmezZlVH",
            "name": "Bearer Auth account"
          }
        }
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/emails/test/send",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"conversationId\": \"{{ $json.data.conversationId }}\", \"to\": \"{{ $('Loop Stores').item.json['Store Owner Email'] }}\"}",
          "options": {}
        },
        "id": "7ea88642-5680-49ff-ae09-df719a68f773",
        "name": "Send Test Email",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [
          608,
          144
        ]
      },
      {
        "parameters": {},
        "type": "n8n-nodes-base.manualTrigger",
        "typeVersion": 1,
        "position": [
          -1920,
          352
        ],
        "id": "bb3666c4-1a2b-4638-8b50-c90e91761c82",
        "name": "When clicking ‘Execute workflow’"
      },
      {
        "parameters": {
          "url": "=https://api.migma.ai/v1/projects/import/{{ $json.data.projectId }}/status",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "options": {}
        },
        "id": "3d6bf6d2-cfd7-4106-b291-a658cd3dc7db",
        "name": "Check Import Status1",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [
          -1168,
          352
        ],
        "credentials": {
          "httpBearerAuth": {
            "id": "StqUFSi6OmezZlVH",
            "name": "Bearer Auth account"
          }
        }
      },
      {
        "parameters": {
          "conditions": {
            "string": [
              {
                "value1": "={{ $json.data.status }}",
                "operation": "equals",
                "value2": "active"
              }
            ]
          }
        },
        "id": "8cd0a55d-23fa-47d7-a42c-4e3377f587c9",
        "name": "Is Complete?1",
        "type": "n8n-nodes-base.if",
        "typeVersion": 1,
        "position": [
          -992,
          352
        ]
      },
      {
        "parameters": {
          "amount": 10
        },
        "type": "n8n-nodes-base.wait",
        "typeVersion": 1.1,
        "position": [
          -784,
          368
        ],
        "id": "5930e29f-c31b-4f8c-a5b9-6595df8a3e41",
        "name": "Wait1",
        "webhookId": "318bf499-3ab0-4862-979e-7ae8f7555e66"
      }
    ],
    "pinData": {},
    "connections": {
      "Read Stores": {
        "main": [
          [
            {
              "node": "Loop Stores",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Loop Stores": {
        "main": [
          [
            {
              "node": "Import Store",
              "type": "main",
              "index": 0
            }
          ],
          [
            {
              "node": "Import Store",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Import Store": {
        "main": [
          [
            {
              "node": "Check Import Status1",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Wait": {
        "main": [
          [
            {
              "node": "Is Ready?",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Is Ready?": {
        "main": [
          [
            {
              "node": "Send Test Email",
              "type": "main",
              "index": 0
            }
          ],
          [
            {
              "node": "Wait",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Connect Shopify": {
        "main": [
          [
            {
              "node": "Generate Email",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Generate Email": {
        "main": [
          [
            {
              "node": "Check Generation",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Check Generation": {
        "main": [
          [
            {
              "node": "Is Ready?",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Send Test Email": {
        "main": [
          [
            {
              "node": "Loop Stores",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "When clicking ‘Execute workflow’": {
        "main": [
          [
            {
              "node": "Read Stores",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Check Import Status1": {
        "main": [
          [
            {
              "node": "Is Complete?1",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Is Complete?1": {
        "main": [
          [
            {
              "node": "Connect Shopify",
              "type": "main",
              "index": 0
            }
          ],
          [
            {
              "node": "Wait1",
              "type": "main",
              "index": 0
            }
          ]
        ]
      },
      "Wait1": {
        "main": [
          [
            {
              "node": "Check Import Status1",
              "type": "main",
              "index": 0
            }
          ]
        ]
      }
    },
    "active": false,
    "settings": {
      "executionOrder": "v1"
    },
    "versionId": "52001030-f518-4ec1-9ecb-ef3adc46bf07",
    "meta": {
      "instanceId": "2d68fadaa6ab455961c0fbd849b7b2cf998bc0f9d88f3977fe8e22efddd544b8"
    },
    "id": "Gk1gFIZGdAKIJ7oo",
    "tags": []
  }
  ```
</Accordion>

This workflow:

1. Imports a brand
2. Waits and checks if import is complete (loops until done)
3. Generates an email
4. Waits and checks if generation is complete (loops until done)
5. Exports the final HTML

## Advanced Use Cases

### Shopify Multi-Store Automation

For processing multiple Shopify stores from a spreadsheet, see this advanced workflow:

<Steps>
  <Step title="Prepare Your Data">
    Create a Google Sheet with columns: `Store URL`, `Store Owner Email`, `Store Name`
  </Step>

  <Step title="Read from Sheet">
    Use n8n's Google Sheets node to read all stores
  </Step>

  <Step title="Loop Through Stores">
    Use "Split in Batches" node to process each store one at a time
  </Step>

  <Step title="For Each Store">
    1. Import brand: `POST /v1/projects/import`
    2. Connect Shopify: `POST /v1/shopify/connect`
    3. Generate email: `POST /v1/projects/emails/generate`
    4. Send test email: `POST /v1/emails/test/send`
  </Step>
</Steps>

<Accordion title="Shopify Multi-Store Workflow JSON">
  ```json theme={null}
  {
    "name": "Migma: Shopify Multi-Store",
    "nodes": [
      {
        "parameters": {
          "documentId": "YOUR_GOOGLE_SHEET_ID",
          "sheetName": "Sheet1",
          "options": {}
        },
        "id": "read-sheet",
        "name": "Read Stores",
        "type": "n8n-nodes-base.googleSheets",
        "typeVersion": 3,
        "position": [250, 300],
        "credentials": {
          "googleSheetsOAuth2Api": {
            "id": "YOUR_GOOGLE_CREDENTIAL_ID",
            "name": "Google Sheets"
          }
        }
      },
      {
        "parameters": {
          "batchSize": 1,
          "options": {}
        },
        "id": "loop",
        "name": "Loop Stores",
        "type": "n8n-nodes-base.splitInBatches",
        "typeVersion": 3,
        "position": [450, 300]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/projects/import",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"urls\": [\"{{ $json['Store URL'] }}\"]}",
          "options": {}
        },
        "id": "import-store",
        "name": "Import Store",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [650, 300],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      },
      {
        "parameters": {
          "amount": 10,
          "unit": "seconds"
        },
        "id": "wait",
        "name": "Wait",
        "type": "n8n-nodes-base.wait",
        "typeVersion": 1,
        "position": [850, 300],
        "webhookId": "wait-webhook"
      },
      {
        "parameters": {
          "method": "GET",
          "url": "=https://api.migma.ai/v1/projects/import/{{ $json.data.projectId }}/status",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "options": {}
        },
        "id": "check-status",
        "name": "Check Status",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [1050, 300],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      },
      {
        "parameters": {
          "conditions": {
            "string": [
              {
                "value1": "={{ $json.data.status }}",
                "operation": "equals",
                "value2": "active"
              }
            ]
          }
        },
        "id": "is-ready",
        "name": "Is Ready?",
        "type": "n8n-nodes-base.if",
        "typeVersion": 1,
        "position": [1250, 300]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/shopify/connect",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"projectId\": \"{{ $json.data.projectId }}\", \"shopifyStoreUrl\": \"{{ $('Loop Stores').item.json['Store URL'] }}\"}",
          "options": {}
        },
        "id": "connect-shopify",
        "name": "Connect Shopify",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [1450, 200],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/projects/emails/generate",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"projectId\": \"{{ $json.data.projectId }}\", \"prompt\": \"Create a welcome email\", \"webMode\": true}",
          "options": {}
        },
        "id": "generate-email",
        "name": "Generate Email",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [1650, 200],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      },
      {
        "parameters": {
          "amount": 5,
          "unit": "seconds"
        },
        "id": "wait-gen",
        "name": "Wait",
        "type": "n8n-nodes-base.wait",
        "typeVersion": 1,
        "position": [1850, 200],
        "webhookId": "wait-webhook-gen"
      },
      {
        "parameters": {
          "method": "GET",
          "url": "=https://api.migma.ai/v1/projects/emails/{{ $json.data.conversationId }}/status",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "options": {}
        },
        "id": "check-gen",
        "name": "Check Generation",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [2050, 200],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      },
      {
        "parameters": {
          "conditions": {
            "string": [
              {
                "value1": "={{ $json.data.status }}",
                "operation": "equals",
                "value2": "completed"
              }
            ]
          }
        },
        "id": "is-gen-ready",
        "name": "Is Ready?",
        "type": "n8n-nodes-base.if",
        "typeVersion": 1,
        "position": [2250, 200]
      },
      {
        "parameters": {
          "method": "POST",
          "url": "https://api.migma.ai/v1/emails/test/send",
          "authentication": "genericCredentialType",
          "genericAuthType": "httpBearerAuth",
          "sendHeaders": true,
          "headerParameters": {
            "parameters": [
              {
                "name": "Content-Type",
                "value": "application/json"
              }
            ]
          },
          "sendBody": true,
          "specifyBody": "json",
          "jsonBody": "={\"conversationId\": \"{{ $json.data.conversationId }}\", \"to\": \"{{ $('Loop Stores').item.json['Store Owner Email'] }}\"}",
          "options": {}
        },
        "id": "send-email",
        "name": "Send Test Email",
        "type": "n8n-nodes-base.httpRequest",
        "typeVersion": 4,
        "position": [2450, 100],
        "credentials": {
          "httpBearerAuth": {
            "id": "YOUR_CREDENTIAL_ID",
            "name": "Migma API"
          }
        }
      }
    ],
    "connections": {
      "Read Stores": {
        "main": [[{ "node": "Loop Stores", "type": "main", "index": 0 }]]
      },
      "Loop Stores": {
        "main": [[{ "node": "Import Store", "type": "main", "index": 0 }]]
      },
      "Import Store": {
        "main": [[{ "node": "Wait", "type": "main", "index": 0 }]]
      },
      "Wait": {
        "main": [[{ "node": "Check Status", "type": "main", "index": 0 }]]
      },
      "Check Status": {
        "main": [[{ "node": "Is Ready?", "type": "main", "index": 0 }]]
      },
      "Is Ready?": {
        "main": [
          [{ "node": "Connect Shopify", "type": "main", "index": 0 }],
          [{ "node": "Wait", "type": "main", "index": 0 }]
        ]
      },
      "Connect Shopify": {
        "main": [[{ "node": "Generate Email", "type": "main", "index": 0 }]]
      },
      "Generate Email": {
        "main": [[{ "node": "Wait", "type": "main", "index": 0 }]]
      },
      "Check Generation": {
        "main": [[{ "node": "Is Ready?", "type": "main", "index": 0 }]]
      },
      "Is Ready?": {
        "main": [
          [{ "node": "Send Test Email", "type": "main", "index": 0 }],
          [{ "node": "Wait", "type": "main", "index": 0 }]
        ]
      },
      "Send Test Email": {
        "main": [[{ "node": "Loop Stores", "type": "main", "index": 0 }]]
      }
    }
  }
  ```
</Accordion>

<Info>
  **Note:** To send test emails, make sure your API key has the `EMAIL_SEND` permission enabled in Migma Settings → Developers → API Keys.
</Info>

### Using Webhooks Instead of Polling

For better performance, use [Migma webhooks](/webhooks) instead of wait/check loops:

1. Add a **Webhook** node in n8n and copy the webhook URL
2. In Migma Settings → Developers → Webhooks, create a webhook
3. Subscribe to events: `project.import.completed` and `email.generation.completed`
4. Your n8n workflow will be triggered automatically when events occur

## Tips

<AccordionGroup>
  <Accordion title="Passing Data Between Nodes" icon="arrow-right">
    Use n8n expressions to reference previous node data:

    * `{{ $json.data.projectId }}` - Access projectId from current node
    * `{{ $('Import Brand').item.json.data.projectId }}` - Access data from specific node
  </Accordion>

  <Accordion title="Handling Errors" icon="triangle-exclamation">
    Add an **Error Trigger** node to catch failures and send alerts or retry logic.
  </Accordion>

  <Accordion title="Batch Processing" icon="layer-group">
    Use **Split in Batches** node to process multiple items from spreadsheets or databases.
  </Accordion>

  <Accordion title="Export Formats" icon="file-export">
    Available export endpoints:

    * `/v1/export/html/{conversationId}` - Standard HTML
    * `/v1/export/klaviyo/{conversationId}` - Klaviyo format
    * `/v1/export/mailchimp/{conversationId}` - Mailchimp format
    * `/v1/export/png/{conversationId}` - PNG image
  </Accordion>
</AccordionGroup>

## Need Help?

<CardGroup>
  <Card title="API Documentation" icon="book" href="/api-reference/introduction">
    Complete API reference with all endpoints
  </Card>

  <Card title="Webhooks" icon="bolt" href="/webhooks">
    Set up real-time event notifications
  </Card>

  <Card title="n8n Documentation" icon="book" href="https://docs.n8n.io">
    Learn more about n8n
  </Card>

  <Card title="Join Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Get help from the community
  </Card>
</CardGroup>


# Use Migma with OpenClaw
Source: https://docs.migma.ai/openclaw

Connect Migma to OpenClaw so an agent can create, edit, validate, and prepare email work from WhatsApp, Telegram, Discord, or Slack.

[OpenClaw](https://openclaw.ai/) is an open-source AI agent for WhatsApp, Telegram, Discord, and Slack. The official Migma skill gives it the ability to generate, send, validate, and export emails from a chat message.

<Info>
  Want a one-click Slack bot instead? See [Migma for Slack](/integrations/slack). Building your own dedicated Slack app? Use [Agent Auth](/agent-auth) for per-user access.
</Info>

<CardGroup>
  <Card title="Any chat platform" icon="message">
    WhatsApp, Telegram, Discord, Slack
  </Card>

  <Card title="Full email workflow" icon="envelope">
    Generate, validate, send, and export
  </Card>

  <Card title="Skill install" icon="download">
    Install the official skill, then run `migma login`
  </Card>
</CardGroup>

***

## Installation

<CodeGroup>
  ```bash OpenClaw CLI theme={null}
  openclaw skills install MigmaAI/migma-skills/skills/migma
  ```

  ```bash ClawHub theme={null}
  npx clawhub@latest install migma
  ```
</CodeGroup>

***

## Configuration

Run `migma login`, or fetch `https://api.migma.ai/auth.md` and approve the code. For CI, set `MIGMA_API_KEY` in `~/.openclaw/openclaw.json`:

```json theme={null}
{
  "skills": {
    "entries": {
      "migma": {
        "enabled": true,
        "env": {
          "MIGMA_API_KEY": "your_migma_api_key"
        }
      }
    }
  }
}
```

Get access with `migma login` or [agent registration](/agent-registration). Settings keys are for CI only.

Optionally, set a default project ID to skip specifying it each time:

```json theme={null}
"MIGMA_PROJECT_ID": "your_project_id"
```

Verify the skill is loaded:

```bash theme={null}
openclaw skills list --eligible
```

***

## Quick start

<Steps>
  <Step title="Create a sending domain">
    Tell your agent: *"Set up a sending domain for mycompany"*

    This creates `hello@mycompany.migma.email` — verified instantly, no DNS needed. See [Sending Domains](/sending-domains/overview).
  </Step>

  <Step title="Set a default project">
    *"List my projects and set one as default"*

    A project holds your brand identity (logo, colors, fonts, tone). If you don't have one: *"Import our brand from [https://yourbrand.com](https://yourbrand.com)"*
  </Step>

  <Step title="Generate and send">
    *"Create a welcome email and send it to [sarah@example.com](mailto:sarah@example.com)"*

    The agent generates the email, picks the returned `emailId`, then sends that specific email from your configured sender.
  </Step>
</Steps>

<Tip>
  Want to send from your own domain? See [Add a Custom Domain](/sending-domains/add-domain) for DNS setup.
</Tip>

***

## Features

The official skill provides:

| Feature | Description |
| - | - |
| **AI email generation** | Describe what you want, get production-ready HTML |
| **Instant sending** | Send through [managed domains](/sending-domains/overview) — no DNS setup. Connect [external providers](/integrations/email-service-providers) like SES or Resend. |
| **[Validation](/email-editor/email-preflight)** | Deliverability, spam score, links, compatibility |
| **[Audience management](/audience/overview)** | Contacts, tags, segments, [bulk CSV import](/audience/csv-upload) |
| **Batch campaigns** | Send to a tag or segment in one command |
| **Platform export** | [Klaviyo](/integrations/klaviyo), [Mailchimp](/integrations/mailchimp), HubSpot, PDF, PNG. See [export options](/email-editor/export-options). |
| **[Brand import](/get-started/configure-brand)** | Import from any website automatically |
| **Personalization** | Contacts and subscriber data included automatically |

***

## Example prompts

* "Create a welcome email for new subscribers"
* "Create a three-email onboarding series and show me each email ID"
* "Make the welcome email shorter and more transactional"
* "Design a Black Friday sale email with 30% off"
* "Send that email to [sarah@example.com](mailto:sarah@example.com)"
* "Check if this email will land in spam"
* "Send our newsletter to the VIP segment"
* "Export this email to Klaviyo"
* "Import our brand from [https://ourwebsite.com](https://ourwebsite.com)"
* "Add [john@example.com](mailto:john@example.com) to our contacts"
* "Create a product launch email, validate it, then send to our launch list"

***

## Custom skill

For more control, you can create a custom skill instead of using the official one. See the [full OpenClaw tutorial](/tutorials/send-emails-from-openclaw) for the custom skill setup with `SKILL.md` and curl-based API calls.

***

## Resources

<CardGroup>
  <Card title="ClawHub" icon="lobster" href="https://clawhub.com/migma">
    Official skill on ClawHub
  </Card>

  <Card title="Full Tutorial" icon="graduation-cap" href="/tutorials/send-emails-from-openclaw">
    Step-by-step setup guide
  </Card>

  <Card title="OpenClaw Docs" icon="book-open" href="https://docs.openclaw.ai">
    OpenClaw documentation
  </Card>

  <Card title="SDK" icon="code" href="/sdk">
    Node.js SDK
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Full endpoint docs
  </Card>

  <Card title="Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Community support
  </Card>
</CardGroup>


# Migma API Quickstart
Source: https://docs.migma.ai/quickstart

Make your first Migma API request in under five minutes: create an API key, import a brand, generate an email, and verify the result.

## Authenticate

Create an account at [migma.ai](https://migma.ai), then pick the first path that works:

<Steps>
  <Step title="Hosted MCP">
    Add `https://migma.ai/mcp` in your agent client and approve access in the browser.
  </Step>

  <Step title="CLI">
    Install the [CLI](/cli) and run `migma login`. A browser window opens; the key is stored for you.
  </Step>

  <Step title="Claim-code or CI">
    Direct agents that cannot complete an OAuth callback, but can call the API, poll, and securely store a credential, should fetch `https://api.migma.ai/auth.md`. CI and servers set `MIGMA_API_KEY`.
  </Step>
</Steps>

<Tip>
  Do not send agents to Settings to copy a key. Settings keys are for CI and server automation only.
</Tip>

## Import Your Brand

Before generating emails, you need to import your brand information:

```typescript Node.js SDK theme={null}
import Migma from 'migma';

const migma = new Migma(process.env.MIGMA_API_KEY);

// importAndWait polls automatically until the brand is ready
const { data, error } = await migma.projects.importAndWait({
  urls: ['https://yourbrand.com']
});

console.log('Project ID:', data.projectId);
```

```bash cURL theme={null}
curl -X POST https://api.migma.ai/v1/projects/import \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://yourbrand.com"],
    "name": "My Brand"
  }'
```

```javascript JavaScript theme={null}
const response = await fetch('https://api.migma.ai/v1/projects/import', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    urls: ['https://yourbrand.com'],
    name: 'My Brand'
  })
});

const data = await response.json();
console.log('Project ID:', data.data.projectId);
```

```python Python theme={null}
import requests

response = requests.post(
    'https://api.migma.ai/v1/projects/import',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'urls': ['https://yourbrand.com'],
        'name': 'My Brand'
    }
)

data = response.json()
print(f"Project ID: {data['data']['projectId']}")
```

<Info>
  Brand import is asynchronous. The SDK's `importAndWait` handles polling automatically. With raw HTTP, save the `projectId` and poll the status endpoint or use webhooks.
</Info>

## Generate Your First Email

Once your brand is imported, generate an email:

```typescript Node.js SDK theme={null}
// generateAndWait polls automatically until the email is ready
const { data, error } = await migma.emails.generateAndWait({
  projectId: 'your_project_id',
  prompt: 'Create a welcome email for new subscribers',
  languages: ['en']
});

const firstEmail = data.result.emails[0];
console.log('Email ID:', firstEmail.emailId);
console.log('HTML:', firstEmail.html);
console.log('Screenshot:', firstEmail.screenshotUrl);
```

```bash cURL theme={null}
curl -X POST https://api.migma.ai/v1/projects/emails/generate \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "your_project_id",
    "prompt": "Create a welcome email for new subscribers",
    "languages": ["en"]
  }'
```

```javascript JavaScript theme={null}
const response = await fetch(
  'https://api.migma.ai/v1/projects/emails/generate',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      projectId: projectId,
      prompt: 'Create a welcome email for new subscribers',
      languages: ['en']
    })
  }
);

const data = await response.json();
console.log('Conversation ID:', data.data.conversationId);
console.log('Status:', data.data.status); // 'pending'
```

```python Python theme={null}
response = requests.post(
    'https://api.migma.ai/v1/projects/emails/generate',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        'projectId': project_id,
        'prompt': 'Create a welcome email for new subscribers',
        'languages': ['en']
    }
)

data = response.json()
print(f"Conversation ID: {data['data']['conversationId']}")
print(f"Status: {data['data']['status']}")  # 'pending'
```

## Poll for Status

Email generation is asynchronous. Use the SDK's `generateAndWait` — it handles polling automatically. Or set up [webhooks](/webhooks) to get notified when generation completes without polling at all.

<AccordionGroup>
  <Accordion title="Manual polling with the SDK">
    ```typescript theme={null}
    const { data } = await migma.emails.getGenerationStatus('conversation_id');

    if (data.status === 'completed') {
      const firstEmail = data.result.emails[0];
      console.log('Email ID:', firstEmail.emailId);
      console.log('HTML:', firstEmail.html);
    }
    ```
  </Accordion>
</AccordionGroup>

## Get, Edit, and Send the Generated Email

Use `emailId` from `result.emails[]` to fetch, prompt-edit, test-send, or send one generated email. This is required for email series because `conversationId` points at the whole generation.

```typescript Node.js SDK theme={null}
const { data } = await migma.emails.getGenerationStatus(conversationId);

if (data.status === 'completed') {
  const selected = data.result.emails[0];
  const email = await migma.emails.get(selected.emailId);

  console.log('HTML:', email.data.html);
  console.log('Screenshot:', email.data.screenshotUrl);

  await migma.emails.edit(selected.emailId, {
    prompt: 'Make this welcome email shorter and more transactional'
  });

  await migma.sending.send({
    recipientType: 'email',
    recipientEmail: 'sarah@example.com',
    from: 'hello@yourbrand.migma.email',
    fromName: 'Your Brand',
    subject: selected.subject,
    emailId: selected.emailId
  });
}
```

```bash cURL theme={null}
curl https://api.migma.ai/v1/emails/{emailId} \
  -H "Authorization: Bearer YOUR_API_KEY"

curl -X POST https://api.migma.ai/v1/emails/{emailId}/edit \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Make this welcome email shorter and more transactional"}'

curl -X POST https://api.migma.ai/v1/sending \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "recipientType": "email",
    "recipientEmail": "sarah@example.com",
    "from": "hello@yourbrand.migma.email",
    "fromName": "Your Brand",
    "subject": "Welcome",
    "emailId": "EMAIL_ID"
  }'
```

```javascript JavaScript theme={null}
const response = await fetch(
  `https://api.migma.ai/v1/projects/emails/${conversationId}/status`,
  {
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

const data = await response.json();

if (data.data.status === 'completed') {
  const selected = data.data.result.emails[0];
  const emailHtml = selected.html;
  const emailId = selected.emailId;

  console.log('Email ID:', emailId);
  console.log('Generated HTML:', emailHtml);
}
```

## Complete Example

Here's a complete workflow from import to generated HTML:

```typescript Node.js SDK theme={null}
import Migma from 'migma';

const migma = new Migma(process.env.MIGMA_API_KEY);

// 1. Import brand (waits for completion automatically)
const brand = await migma.projects.importAndWait({
  urls: ['https://yourbrand.com']
});
console.log('Brand imported:', brand.data.projectId);

// 2. Generate email (waits for completion automatically)
const email = await migma.emails.generateAndWait({
  projectId: brand.data.projectId,
  prompt: 'Create a welcome email for new subscribers',
  languages: ['en']
});

console.log('Subject:', email.data.result.subject);
const selectedEmail = email.data.result.emails[0];
console.log('Email ID:', selectedEmail.emailId);
console.log('HTML:', selectedEmail.html.substring(0, 200) + '...');
```

## Next steps

<CardGroup>
  <Card title="Node.js SDK" icon="npm" href="/sdk">
    Full SDK guide with error handling, polling, and all 14 resources
  </Card>

  <Card title="CLI" icon="terminal" href="/cli">
    Generate, send, and validate from your terminal
  </Card>

  <Card title="MCP" icon="server" href="/mcp-server">
    Connect Migma to Cursor, Codex, Claude, VS Code, and other AI tools
  </Card>

  <Card title="Skills" icon="wand-magic-sparkles" href="/skills">
    Add Migma to AI coding assistants
  </Card>

  <Card title="Set Up Webhooks" icon="bolt" href="/webhooks">
    Real-time notifications instead of polling
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Full endpoint documentation
  </Card>
</CardGroup>

## Common Issues

<AccordionGroup>
  <Accordion title="401 Unauthorized">
    Check that your API key is correct and included in the `Authorization` header as `Bearer YOUR_API_KEY`
  </Accordion>

  <Accordion title="Import takes too long">
    Brand imports can take 30-60 seconds. Use webhooks to get notified when complete instead of polling.
  </Accordion>

  <Accordion title="Generation fails">
    Check the error message in the response. Common issues:

    * Invalid projectId (brand not imported yet)
    * Prompt is too vague or too long
    * Rate limit exceeded
  </Accordion>

  <Accordion title="HTML looks broken">
    The generated HTML is optimized for email clients. Run [email preflight checks](/email-editor/email-preflight) to test compatibility across 30+ clients, or send a test email to yourself first.
  </Accordion>
</AccordionGroup>


# Lifecycle Email Recipes
Source: https://docs.migma.ai/recipes/lifecycle-emails

Use Migma lifecycle email recipes for welcome, onboarding, product updates, re-engagement, dunning, and winback messages across the customer journey.

Lifecycle emails respond to where someone is in the customer journey. Use Migma to draft and preflight the emails. Send one-off lifecycle campaigns from Migma, or export emails to an ESP when the flow needs event triggers.

***

## First touch

Send when someone subscribes, joins a waitlist, creates an account, or requests content.

```text theme={null}
Create a welcome email for someone who just joined our list.
Confirm what they signed up for, set expectations, and give them one useful next step.
Tone: warm, direct, and specific.
```

## Onboarding

Use a 3 to 5 email series when people need structure before they see value.

```text theme={null}
Create a 4-email onboarding series.

Email 1: welcome and one first action.
Email 2: quick-start tip.
Email 3: customer story or proof point.
Email 4: check-in with one helpful CTA.

Space emails across two weeks.
```

## Product update

Use a campaign when content changes each month or release.

```text theme={null}
Create a product update email with three updates.
For each update: one-line summary, why it matters, and a link.
End with one primary CTA.
```

## Re-engagement

Use when contacts have stopped opening or clicking.

```text theme={null}
Create a 3-email re-engagement sequence for inactive subscribers.

Email 1: lead with something new or useful.
Email 2: ask if they still want updates.
Email 3: final reminder with a clear unsubscribe or preference option.
```

## Payment failure

Use for dunning emails. Export to the billing or ESP system that owns the payment event.

```text theme={null}
Create a 3-email payment failure sequence.

Email 1: payment failed, no blame, link to update payment.
Email 2: access may be interrupted, clear deadline.
Email 3: final notice before pause.

Tone: respectful, clear, not aggressive.
```

## Winback

Use for customers who churned or stopped buying.

```text theme={null}
Create a winback email for customers who have not purchased in 6 months.
Lead with what has changed, show one relevant product or improvement,
and include one CTA to come back.
```

***

## Where to build

| Need | Migma workflow |
| - | - |
| One email | [Prompt guide](/creating-emails/prompt-based-creation) |
| Multi-email sequence | [Email Series](/creating-emails/email-series) |
| Visual planning | [Visual Canvas](/creating-emails/visual-canvas) |
| Manual send | [Campaigns](/campaigns/overview) |
| Event-triggered flow | [Export](/email-editor/export-options) to the ESP or automation tool that owns the trigger |

***

## Related

<CardGroup>
  <Card title="Build a welcome flow" icon="layer-group" href="/recipes/welcome-flow">
    Detailed welcome sequence recipe.
  </Card>

  <Card title="Campaigns vs series" icon="scale-balanced" href="/campaigns/campaigns-vs-email-series">
    Choose how to create and send.
  </Card>

  <Card title="Klaviyo" icon="plug" href="/integrations/klaviyo">
    Export Migma emails into Klaviyo flows.
  </Card>

  <Card title="Mailchimp" icon="plug" href="/integrations/mailchimp">
    Export Migma emails into Mailchimp.
  </Card>
</CardGroup>


# Send a Segmented Newsletter
Source: https://docs.migma.ai/recipes/segmented-newsletter

Build and send a segmented Migma newsletter by defining the audience, generating relevant content, running preflight checks, and reviewing recipients.

Use this recipe when one newsletter should go to a specific audience instead of everyone on the list. Build the segment first, create the email, run preflight, then send a campaign.

***

## Build the segment

<Steps>
  <Step title="Open Audience">
    Go to **Audience → Segments**.
  </Step>

  <Step title="Choose filters">
    Combine status, tags, engagement, language, custom fields, or validation status.
  </Step>

  <Step title="Preview contacts">
    Check the estimated audience before saving. Remove risky or irrelevant contacts.
  </Step>

  <Step title="Save the segment">
    Give the segment a clear name, such as `Newsletter: active subscribers`.
  </Step>
</Steps>

***

## Prompt

```text theme={null}
Create a newsletter for active subscribers.

Include:
- One short intro
- Three updates
- One useful tip
- One primary CTA

Keep it skimmable and avoid sounding like a changelog.
```

***

## Send

<Steps>
  <Step title="Create the email">
    Generate the newsletter from the prompt, then edit the copy and layout.
  </Step>

  <Step title="Run preflight">
    Check rendering, links, compliance basics, and spam-risk signals.
  </Step>

  <Step title="Create a campaign">
    Open **Campaigns → New Campaign**, choose the email, and select the saved segment as recipients.
  </Step>

  <Step title="Send or schedule">
    Configure sender, send a test, then send now or schedule.
  </Step>
</Steps>

***

## Related

<CardGroup>
  <Card title="Segments" icon="tag" href="/audience/manage-tags-and-segments">
    Build reusable audiences.
  </Card>

  <Card title="Send campaign" icon="paper-plane" href="/campaigns/send-campaign">
    Launch the newsletter.
  </Card>

  <Card title="Reading analytics" icon="chart-line" href="/campaigns/track-results">
    Review performance after sending.
  </Card>

  <Card title="Audience hygiene" icon="shield-check" href="/audience/deliverability">
    Keep the segment healthy.
  </Card>
</CardGroup>


# Build a Welcome Flow
Source: https://docs.migma.ai/recipes/welcome-flow

Create a Migma welcome flow for new subscribers, customers, trial users, or members, then review each email and choose how to send or export it.

A welcome flow introduces new subscribers, customers, trial users, or community members. In Migma, build the sequence with [Email Series](/creating-emails/email-series), review each email, then send through Migma or export to your ESP for triggered automation.

***

## Prompt

```text theme={null}
Create a 4-email welcome series for new subscribers.

Email 1: welcome them and set expectations.
Email 2: explain the main problem we help solve.
Email 3: show one product, customer story, or useful resource.
Email 4: invite them to take the next step.

Tone: clear, helpful, confident.
```

***

## Build it

<Steps>
  <Step title="Create the series">
    Open **Create**, paste the prompt, and ask for a multi-email series.
  </Step>

  <Step title="Review the arc">
    Open the [Visual Canvas](/creating-emails/visual-canvas). Check that each email has a clear job and the sequence does not repeat itself.
  </Step>

  <Step title="Set cadence">
    Use send offsets such as day 0, day 2, day 5, and day 9.
  </Step>

  <Step title="Preflight each email">
    Run [Email Preflight](/email-editor/email-preflight) before sending or exporting.
  </Step>

  <Step title="Choose delivery path">
    Send as campaigns in Migma when you control the timing manually, or export to Klaviyo, Mailchimp, HubSpot, Brevo, or another ESP for event-triggered automation.
  </Step>
</Steps>

***

## Checks before launch

* Audience uses clear opt-in.
* Every email has one primary CTA.
* Cadence gives people time to act.
* Unsubscribe and preference links work.
* Each email passes preflight.

***

## Related

<CardGroup>
  <Card title="Email series" icon="layer-group" href="/creating-emails/email-series">
    Generate and refine the sequence.
  </Card>

  <Card title="Campaigns vs series" icon="scale-balanced" href="/campaigns/campaigns-vs-email-series">
    Choose the right workflow.
  </Card>

  <Card title="Export options" icon="arrow-up-right" href="/email-editor/export-options">
    Move the sequence to another ESP.
  </Card>

  <Card title="Sending rules" icon="envelope-circle-check" href="/get-started/what-you-can-send">
    Confirm permission before sending.
  </Card>
</CardGroup>


# Referral FAQ
Source: https://docs.migma.ai/referral/faq

How Migma referrals, commissions, and payouts work through Tolt.

## Links and Rewards

<AccordionGroup>
  <Accordion title="How do I get my referral link?">
    Sign in at [migma.ai/referral](https://migma.ai/referral) or open **Settings → Referral**, then select **Copy link**.
  </Accordion>

  <Accordion title="Does my existing Tolt link still work?">
    Yes. Keep using it. Your referrals and commissions remain in the same Tolt program.
  </Accordion>

  <Accordion title="Where can I see the current reward?">
    Open the [partner portal](https://affiliate.migma.ai) for the commission offer and its conditions. Check those terms before sharing specific reward amounts.
  </Accordion>

  <Accordion title="Does the invited business receive a discount?">
    Any eligible referral discount appears in checkout before payment. The checkout total confirms the amount being charged.
  </Accordion>

  <Accordion title="Are rewards added to my Migma bill or AI credits?">
    Referral rewards are Tolt commissions. They are not automatically added to your Migma bill or AI usage-credit balance.
  </Accordion>

  <Accordion title="Where can I track my earnings?">
    Your referral page shows pending and total earned commissions. Open the partner portal for full commission and payout details.
  </Accordion>

  <Accordion title="What if my referral details do not load?">
    Select **Retry** or **Open partner portal**. If the problem continues, contact [support@migma.ai](mailto:support@migma.ai).
  </Accordion>
</AccordionGroup>

Read the [referral overview](/referral/overview) or [commissions and payouts guide](/referral/payouts).


# Referral Program
Source: https://docs.migma.ai/referral/overview

Share your Migma referral link and track commissions and payouts through Tolt.

## Refer a Business

Migma's referral program runs through Tolt. Your referral link, customer attribution, commissions, and payouts stay in the same program.

## Share Your Link

<Steps>
  <Step title="Get your referral link">
    Sign in at [migma.ai/referral](https://migma.ai/referral) or open **Settings → Referral**. Select **Copy link**.
  </Step>

  <Step title="Invite a business">
    Share your link with a business that would benefit from Migma. Any customer discount appears in checkout before they pay.
  </Step>

  <Step title="Track your referrals">
    See clicks, signups, customers, and earnings on your referral page. Open the [partner portal](https://affiliate.migma.ai) for commission terms and full payout history.
  </Step>
</Steps>

## Your Existing Link

Keep using your Tolt referral link. No new link or separate bill-credit account is needed. Existing referrals and commissions remain in Tolt.

Check your partner portal for the current commission offer before sharing specific reward amounts. Referral commissions are separate from Migma AI usage credits.

<CardGroup>
  <Card title="Commissions and Payouts" icon="wallet" href="/referral/payouts">
    Where to find earnings and payout details.
  </Card>

  <Card title="Referral FAQ" icon="circle-question" href="/referral/faq">
    Links, rewards, and customer discounts.
  </Card>
</CardGroup>


# Commissions and Payouts
Source: https://docs.migma.ai/referral/payouts

Track Migma referral commissions and manage payout details in Tolt.

## Referral Earnings

Migma uses Tolt for referral commissions and payouts. Open [migma.ai/referral](https://migma.ai/referral) or **Settings → Referral** to see your referral link and earnings.

* **Pending:** commissions waiting for approval.
* **Total earned:** approved commissions recorded in Tolt. This is not your unpaid balance.

## Manage Payouts

Select **Open partner portal** or visit [affiliate.migma.ai](https://affiliate.migma.ai). Review your commission status, payout history, payout details, and the current program terms there.

Approval rules, payout timing, and available payout methods follow the Tolt program settings. A pending commission is not proof of a completed payout.

Referral commissions stay in Tolt. They are separate from your Migma subscription bill and AI usage credits. Your existing referral link and earnings remain in the same program.

Read the [referral FAQ](/referral/faq) or contact [support@migma.ai](mailto:support@migma.ai).


# Migma Node.js SDK
Source: https://docs.migma.ai/sdk

Install the official Migma Node.js and TypeScript SDK to manage brands, generate and send emails, work with contacts, and automate backend workflows.

<Frame>
  <img alt="Developer tools" />
</Frame>

## Installation

<CodeGroup>
  ```bash npm theme={null}
  npm install migma
  ```

  ```bash yarn theme={null}
  yarn add migma
  ```

  ```bash pnpm theme={null}
  pnpm add migma
  ```
</CodeGroup>

**Requirements:** Node.js 18 or later.

Authenticate with `migma login` or `MIGMA_API_KEY` (CI). Hosted MCP clients should connect `https://migma.ai/mcp` instead of constructing the SDK by hand.

## Quick Start

```typescript theme={null}
import Migma from 'migma';

const migma = new Migma(process.env.MIGMA_API_KEY);

// A project holds your brand info (colors, fonts, logos, tone of voice).
// Import one from your website, or use an existing project ID from the dashboard.
const brand = await migma.projects.importAndWait({
  urls: ['https://yourbrand.com']
});

// Generate an email design with AI — returns the finished HTML directly.
const email = await migma.emails.generateAndWait({
  projectId: brand.data.projectId,
  prompt: 'Create a welcome email for new subscribers',
  languages: ['en']
});

if (email.data?.status === 'completed') {
  console.log('Subject:', email.data.result.subject);
  console.log('HTML:', email.data.result.html); // primary email HTML
  console.log('Email ID:', email.data.result.emails[0].emailId);
}
```

<Tip>
  **Prefer async?** Use `migma.emails.generate()` to kick off generation without waiting, then set up a [webhook](/webhooks) to receive an `email.generation.completed` event when the design is ready — no polling needed.
</Tip>

<Card title="OpenClaw" icon="lobster" href="/tutorials/send-emails-from-openclaw">
  Use Migma from WhatsApp, Telegram, and Discord with OpenClaw.
</Card>

## Configuration

```typescript theme={null}
const migma = new Migma('your_api_key', {
  baseUrl: 'https://api.migma.ai/v1', // default
  maxRetries: 2,     // retries on 5xx / 429 (default: 2)
  retryDelay: 1000   // delay between retries in ms (default: 1s)
});
```

## Error Handling

Every method returns `{ data, error }` — it never throws:

```typescript theme={null}
const { data, error } = await migma.contacts.create({
  email: 'sarah@example.com',
  firstName: 'Sarah',
  status: 'subscribed', // only for contacts with marketing consent
  projectId: 'proj_123'
});

if (error) {
  console.error(error.code);       // e.g. 'validation_error'
  console.error(error.statusCode); // e.g. 400
  console.error(error.message);    // human-readable description
  return;
}

// TypeScript narrows — data is guaranteed non-null here
console.log(data.id);
```

**Error codes:** `validation_error`, `not_found`, `unauthorized`, `forbidden`, `rate_limit_exceeded`, `conflict`, `timeout`, `network_error`, `internal_error`, `unknown`

## Async Polling Helpers

Email generation, brand import, and preview creation are asynchronous. The SDK provides `*AndWait` helpers that poll automatically until the operation completes:

```typescript theme={null}
const email = await migma.emails.generateAndWait(
  {
    projectId: 'proj_123',
    prompt: 'Create a product launch email'
  },
  {
    interval: 2000,     // poll every 2s (default)
    maxAttempts: 150,   // give up after 150 polls (default)
    onPoll: (status, attempt) => {
      console.log(`Poll ${attempt}: ${status.status}`);
    }
  }
);
```

All three polling methods:

| Method | Waits for |
| - | - |
| `migma.emails.generateAndWait()` | Email generation to complete |
| `migma.projects.importAndWait()` | Brand import to finish |
| `migma.previews.createAndWait()` | Device preview screenshots |

You can cancel any polling operation with an `AbortController`:

```typescript theme={null}
const controller = new AbortController();
setTimeout(() => controller.abort(), 60000); // 60s timeout

const result = await migma.emails.generateAndWait(params, {
  signal: controller.signal
});
```

## Generated emails and series

Generate one email or a full series from the same API. Pass `count` when you want a specific number of emails; otherwise Migma infers the output from the prompt.

```typescript theme={null}
const { data: series } = await migma.emails.generateAndWait({
  projectId: 'proj_123',
  prompt: 'Create a three-email welcome series for new trial users',
  count: 3
});

if (series?.status === 'completed') {
  for (const email of series.result.emails) {
    console.log(email.slot, email.emailId, email.subject);
    console.log(email.html);
    console.log(email.screenshotUrl);
  }
}
```

`result.html` and `result.subject` are always the primary email for backwards compatibility. Use `result.emails[]` when you need the stable `emailId`, per-email HTML, screenshots, or series order.

## Edit generated emails

Fetch one generated email by ID, run the existing synchronous edit, or start a queued edit:

<Note>
  `startEdit` and `getEditStatus` require an SDK build that includes queued email edits. If your installed package does not expose them, use the REST fallback below. Older SDK builds may also retry synchronous `edit` calls after `5xx` or `429`; create the client with `maxRetries: 0` before making that write, or prefer the idempotent REST async flow.
</Note>

```typescript theme={null}
const { data: email } = await migma.emails.get('email_123');
console.log(email.html);
console.log(email.screenshotUrl);

// Existing synchronous edit. The SDK disables automatic retries for this
// unsafe write. After an ambiguous failure, fetch the email before retrying.
const edited = await migma.emails.edit('email_123', {
  prompt: 'Make this welcome email shorter and more transactional'
});

if (edited.error) throw edited.error;
console.log(edited.data.html);

// Queued edit. startEdit creates an idempotency key and reuses it across its
// HTTP retries. Pass an explicit key to reuse it across caller-level retries.
const started = await migma.emails.startEdit(
  'email_123',
  {
    prompt: 'Use a shorter headline',
    label: 'Short headline'
  },
  { idempotencyKey: 'edit-email_123-short-headline' }
);
if (started.error) throw started.error;

const status = await migma.emails.getEditStatus(
  'email_123',
  started.data.editId
);
if (status.error) throw status.error;

if (status.data.status === 'completed' && status.data.result) {
  console.log(status.data.result.html);
}

if (status.data.status === 'failed') {
  console.error(status.data.error, status.data.changesMayHaveBeenSaved);
  // Fetch and inspect the stored email before starting another edit.
}
```

`startEdit(emailId, { prompt, label? }, options?: CallOptions)` returns `MigmaResult<EmailEditOperation>` after the job is durably queued. It requires `email:write` and `email:read`; credits are checked when the worker starts, with no AI work on the request path. The initial result can have a terminal status on an idempotent replay, but it never includes `result`, so read it with `getEditStatus(emailId, editId)`.

Poll according to `pollAfterMs` until the exact edit status is `completed` or `failed`. Do not use conversation generation status, because a previous turn may already be completed. There is no `editAndWait` helper, and failed or stalled rewrites are not automatically retried. Edit time varies with section and image complexity, provider behavior, and retries; no fixed maximum latency is established.

```bash REST fallback theme={null}
curl -X POST "https://api.migma.ai/v1/emails/EMAIL_ID/edit" \
  -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: edit-email_123-short-headline" \
  -d '{"prompt":"Use a shorter headline","label":"Short headline","async":true}'

curl "https://api.migma.ai/v1/emails/EMAIL_ID/edits/EDIT_ID" \
  -H "Authorization: Bearer $MIGMA_API_KEY"
```

## Email performance

See how a generated email performed across every API send of it, or pull its per-recipient send log:

```typescript theme={null}
const { data: metrics } = await migma.emails.metrics('email_123');
console.log(metrics.summary.openRate, metrics.summary.clickRate);

const { data: logs } = await migma.emails.logs('email_123', { limit: 50, status: 'opened' });
console.log(logs.emails);
```

Numbers arrive asynchronously. Opens are directional — Apple Mail Privacy Protection and bots inflate them — so clicks and delivery are stronger signals.

## Resources

SDK resources cover the public v1 surface used by apps and agents (some advanced campaign/preview routes stay HTTP-only).

| Resource | Methods | Description |
| - | - | - |
| `migma.projects` | `list` `get` `import` `getImportStatus` `retryImport` `importAndWait` | Brand management |
| `migma.emails` | `list` `generate` `importHtml` `getGenerationStatus` `generateAndWait` `importHtmlAndWait` `get` `edit` `startEdit`\* `getEditStatus`\* `sendTest` | Email generation, HTML import, and prompt editing. \*Queued-edit methods require a build containing them. |
| `migma.campaigns` | `list` `create` `get` `send` `schedule` `cancel` `archive` `unarchive` | [Campaign management](/campaigns/overview) |
| `migma.sending` | `send` `getBatchStatus` | [Send emails](/audience/sending-emails) |
| `migma.export` | `getFormats` `getStatus` `html` `mjml` `pdf` `klaviyo` `mailchimp` `hubspot` | [Export to platforms](/email-editor/export-options) |
| `migma.contacts` | `create` `list` `get` `update` `remove` `bulkImport` `getBulkImportStatus` `changeStatus` | [Contact management](/audience/overview) |
| `migma.tags` | `create` `list` `get` `update` `remove` | [Tag management](/audience/overview) |
| `migma.segments` | `create` `list` `get` `update` `remove` | [Audience segments](/audience/overview) |
| `migma.topics` | `create` `list` `get` `update` `remove` `subscribe` `unsubscribe` | [Preference topics](/audience/preference-center) |
| `migma.validation` | `all` `compatibility` `links` `spelling` `deliverability` | [Email testing](/email-editor/email-preflight) |
| `migma.previews` | `create` `get` `getStatus` `getDevice` `getSupportedDevices` `createAndWait` | Device previews |
| `migma.domains` | `list` `create` `get` `verify` `update` `remove` `checkAvailability` `listManaged` `createManaged` `removeManaged` `provisionStream` `setup` | [Sending domains](/sending-domains/overview) |
| `migma.domainPurchases` | `search` `create` `registrations` `listDnsRecords` `addDnsRecord` `removeDnsRecord` | Buy a domain and manage DNS on domains bought in Migma |
| `migma.billing` | `credits` `upgradeLink` | Plan, remaining credits, Stripe upgrade/portal link (user pays in browser) |
| `migma.webhooks` | `list` `create` `get` `update` `remove` `test` `getDeliveries` `getEvents` `getStats` | [Webhook management](/webhooks) |
| `migma.knowledgeBase` | `list` `add` `update` `remove` | Brand knowledge |
| `migma.images` | `add` `update` `remove` `updateLogos` | Project images |

## Complete Example

Here's a full workflow — import a brand, generate an email, [export](/email-editor/export-options) it, and send:

```typescript theme={null}
import Migma from 'migma';

const migma = new Migma(process.env.MIGMA_API_KEY);

// 1. Import your brand
const brand = await migma.projects.importAndWait({
  urls: ['https://yourbrand.com']
});
console.log('Brand imported:', brand.data.projectId);

// 2. Generate an email with AI
const email = await migma.emails.generateAndWait({
  projectId: brand.data.projectId,
  prompt: 'Create a password reset email',
  languages: ['en']
});
console.log('Email ready:', email.data.conversationId);
const selectedEmail = email.data.result.emails[0];
if (!selectedEmail.emailId) throw new Error('No emailId returned');

// 3. Send it
await migma.sending.send({
  recipientType: 'email',
  recipientEmail: 'sarah@example.com',
  from: 'hello@yourbrand.migma.email',
  fromName: 'Your Brand',
  subject: selectedEmail.subject,
  emailId: selectedEmail.emailId,
});
```

For single-email conversations, `conversationId` also works. For multi-slot emails and series, send a specific email with `emailId`:

```typescript theme={null}
await migma.sending.send({
  recipientType: 'email',
  recipientEmail: 'sarah@example.com',
  from: 'hello@yourbrand.migma.email',
  fromName: 'Your Brand',
  subject: 'Reset your password',
  emailId: 'email_123'
});
```

<Tip>
  By default, emails send through Migma's built-in infrastructure. You can also send via [Amazon SES, Resend, SendGrid, or Mailgun](/integrations/email-service-providers) by connecting your provider and passing `providerType` in the send call.
</Tip>

## Resources

<CardGroup>
  <Card title="npm" icon="npm" href="https://www.npmjs.com/package/migma">
    View on npm registry
  </Card>

  <Card title="CLI" icon="terminal" href="/cli">
    Use Migma from the command line
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Full endpoint documentation
  </Card>

  <Card title="Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Get help from the community
  </Card>
</CardGroup>


# Security & Compliance
Source: https://docs.migma.ai/security/compliance

Review Migma security and compliance controls for SOC 2, GDPR, CAN-SPAM, encryption, access management, data handling, and enterprise requirements.

## Overview

Migma is built with enterprise-grade security and compliance at its core. We maintain SOC 2 certification, GDPR compliance, and help you meet email marketing regulations like CAN-SPAM and CASL.

<CardGroup>
  <Card title="SOC 2 Certified" icon="shield-check">
    Third-party audited security controls
  </Card>

  <Card title="GDPR Compliant" icon="scale-balanced">
    Full data privacy compliance for EU
  </Card>

  <Card title="Email Law Compliant" icon="envelope-circle-check">
    CAN-SPAM, CASL, and international regulations
  </Card>
</CardGroup>

<CardGroup>
  <Card title="What you can send" icon="envelope-circle-check" href="/get-started/what-you-can-send">
    Permission-based email and no cold outreach policy.
  </Card>

  <Card title="CAN-SPAM checklist" icon="gavel" href="/compliance/can-spam-checklist">
    Practical U.S. commercial email checklist before sending.
  </Card>

  <Card title="GDPR newsletter consent" icon="user-check" href="/compliance/gdpr-newsletter-consent">
    EU and UK signup and consent best practices.
  </Card>

  <Card title="Acceptable use" icon="file-contract" href="/legal/acceptable-use">
    Platform policy summary for email and marketing use.
  </Card>

  <Card title="Migma MCP" icon="shield-check" href="/security/mcp">
    What the hosted MCP server can do, how OAuth works, and how to revoke access.
  </Card>
</CardGroup>

***

## SOC 2 Compliance

### What is SOC 2?

**SOC 2 (Service Organization Control 2)** is an auditing standard developed by the American Institute of CPAs (AICPA) that ensures service providers securely manage data to protect customer privacy.

**Migma's SOC 2 Type II certification** means we've been independently audited for:

<AccordionGroup>
  <Accordion title="Security" icon="shield-halved">
    **Controls to protect against unauthorized access:**

    ✅ **Access controls**

    * Multi-factor authentication (MFA)
    * Role-based access control (RBAC)
    * Principle of least privilege
    * Regular access reviews

    ✅ **Infrastructure security**

    * Encrypted data transmission (TLS 1.3)
    * Encrypted data at rest (AES-256)
    * Firewall protection
    * Intrusion detection systems

    ✅ **Secure development**

    * Code review processes
    * Security testing
    * Vulnerability scanning
    * Dependency monitoring
  </Accordion>

  <Accordion title="Availability" icon="server">
    **System uptime and reliability:**

    ✅ **99.9% uptime SLA**

    * Redundant infrastructure
    * Load balancing
    * Auto-scaling
    * Disaster recovery plan

    ✅ **Monitoring**

    * 24/7 system monitoring
    * Automated alerting
    * Performance metrics
    * Incident response procedures

    ✅ **Backups**

    * Daily automated backups
    * Multiple backup locations
    * Point-in-time recovery
    * Backup testing quarterly
  </Accordion>

  <Accordion title="Processing Integrity" icon="gears">
    **Data processed completely, accurately, and authorized:**

    ✅ **Quality controls**

    * Input validation
    * Error handling
    * Transaction logging
    * Audit trails

    ✅ **Accuracy**

    * Data validation rules
    * Automated testing
    * Manual verification for critical operations
    * Reconciliation procedures
  </Accordion>

  <Accordion title="Confidentiality" icon="eye-slash">
    **Protection of confidential information:**

    ✅ **Data classification**

    * Public, internal, confidential, restricted
    * Appropriate handling per classification
    * Access controls based on sensitivity

    ✅ **Confidentiality agreements**

    * Employee NDAs
    * Vendor agreements
    * Customer data agreements
  </Accordion>

  <Accordion title="Privacy" icon="user-lock">
    **Personal information collection, use, retention, and disposal:**

    ✅ **Privacy notice**

    * Clear privacy policy
    * Consent mechanisms
    * Purpose limitation
    * Data minimization

    ✅ **Data subject rights**

    * Right to access
    * Right to deletion
    * Right to portability
    * Right to rectification
  </Accordion>
</AccordionGroup>

### SOC 2 Benefits for Customers

<Check>**Trust:** Independent verification of security practices</Check>
<Check>**Compliance:** Helps meet your own compliance requirements</Check>
<Check>**Risk reduction:** Vendor security validated</Check>
<Check>**Due diligence:** Satisfies security questionnaires</Check>

**Need our SOC 2 report?** Contact [enterprise@migma.ai](mailto:enterprise@migma.ai)

***

## GDPR Compliance

### What is GDPR?

**General Data Protection Regulation (GDPR)** is EU law protecting personal data and privacy. It applies to:

* Companies operating in the EU
* Companies offering goods/services to EU residents
* Companies monitoring EU residents' behavior

**Penalties for non-compliance:** Up to €20 million or 4% of global revenue, whichever is higher.

### GDPR Principles

Migma helps you comply with all seven GDPR principles:

<Tabs>
  <Tab title="Lawfulness">
    **Lawful basis for processing personal data**

    Migma supports:

    * ✅ **Consent:** Clear opt-in mechanisms
    * ✅ **Contract:** Transactional emails
    * ✅ **Legitimate interest:** Service communications

    **How Migma helps:**

    * Consent tracking and timestamps
    * Consent withdrawal mechanisms
    * Documented lawful basis
  </Tab>

  <Tab title="Purpose Limitation">
    **Data collected for specified purposes only**

    **Migma's approach:**

    * Clear purpose statements
    * No unexpected data uses
    * Purpose documented in privacy policy

    **Example:**
    Email addresses collected for newsletter → only used for newsletter, not sold to third parties.
  </Tab>

  <Tab title="Data Minimization">
    **Only collect necessary data**

    **Migma collects only:**

    * Email address (required)
    * Name (if provided)
    * Preferences (user-selected)
    * Usage data (for service functionality)

    **We don't collect:**

    * Unnecessary personal data
    * Sensitive categories (race, religion, health)
    * Children's data without verification
  </Tab>

  <Tab title="Accuracy">
    **Keep data accurate and up-to-date**

    **Migma provides:**

    * Preference center for updates
    * Data export for verification
    * Automated bounce handling
    * Regular data cleaning
  </Tab>

  <Tab title="Storage Limitation">
    **Retain data only as long as necessary**

    **Migma's retention:**

    * Active subscribers: Retained while subscribed
    * Unsubscribed: 30 days, then deleted
    * Deleted accounts: Immediate removal
    * Backups: 90-day retention

    **Custom retention:** Enterprise customers can configure
  </Tab>

  <Tab title="Integrity & Confidentiality">
    **Secure data processing**

    **Migma's security:**

    * Encryption in transit (TLS 1.3)
    * Encryption at rest (AES-256)
    * Access controls
    * Regular security audits
    * Incident response plan
  </Tab>

  <Tab title="Accountability">
    **Demonstrate compliance**

    **Migma provides:**

    * Privacy policy
    * Data Processing Agreement (DPA)
    * SOC 2 report
    * Audit logs
    * Compliance documentation
  </Tab>
</Tabs>

### Data Subject Rights

Migma supports all GDPR data subject rights:

<AccordionGroup>
  <Accordion title="Right to Access" icon="folder-open">
    **Individuals can request their data**

    **How to request:**

    1. Email [privacy@migma.ai](mailto:privacy@migma.ai)
    2. Verify identity
    3. Receive data within 30 days

    **What you receive:**

    * All personal data we hold
    * How we use it
    * Who we share it with
    * Retention period
    * Your rights

    **Format:** Machine-readable (JSON/CSV)
  </Accordion>

  <Accordion title="Right to Rectification" icon="pen-to-square">
    **Individuals can correct inaccurate data**

    **Self-service:**

    * Preference center updates
    * Profile management
    * Instant changes

    **Request correction:**

    * Email [privacy@migma.ai](mailto:privacy@migma.ai)
    * Updated within 30 days
  </Accordion>

  <Accordion title="Right to Erasure ('Right to be Forgotten')" icon="eraser">
    **Individuals can request deletion**

    **How to request:**

    1. Click "Delete my account" in settings
    2. Or email [privacy@migma.ai](mailto:privacy@migma.ai)
    3. Confirm deletion request

    **What gets deleted:**

    * ✅ Email address
    * ✅ Name and profile data
    * ✅ Preferences
    * ✅ Email history
    * ✅ Usage data

    **Retained (legal requirements):**

    * Transaction records (tax law)
    * Anonymized analytics
    * Abuse prevention records

    **Timeline:** Immediate deletion, confirmed within 24 hours
  </Accordion>

  <Accordion title="Right to Data Portability" icon="download">
    **Individuals can export their data**

    **Export your data:**

    1. Settings → Privacy → Export Data
    2. Download JSON or CSV
    3. Use anywhere

    **Includes:**

    * Subscriber list with all fields
    * Email templates
    * Campaign history
    * Analytics data
    * Preference settings
  </Accordion>

  <Accordion title="Right to Restrict Processing" icon="hand">
    **Individuals can limit how data is used**

    **How to restrict:**

    1. Preference center → Pause all emails
    2. Or email [privacy@migma.ai](mailto:privacy@migma.ai)

    **Effect:**

    * No marketing emails sent
    * Data retained but not processed
    * Can be reversed anytime
  </Accordion>

  <Accordion title="Right to Object" icon="ban">
    **Individuals can object to processing**

    **Object to:**

    * Direct marketing (unsubscribe)
    * Profiling for marketing
    * Legitimate interest processing

    **How:**

    * Click unsubscribe in any email
    * Preference center
    * Email [privacy@migma.ai](mailto:privacy@migma.ai)
  </Accordion>

  <Accordion title="Right to Withdraw Consent" icon="circle-xmark">
    **Individuals can withdraw consent anytime**

    **Consent for:**

    * Newsletter subscription
    * Marketing emails
    * Data processing

    **Withdraw:**

    * Unsubscribe link
    * Preference center
    * Account deletion
  </Accordion>
</AccordionGroup>

### GDPR Features in Migma

**Built-in compliance tools:**

<Check>**Double opt-in** for EU subscribers (configurable)</Check>
<Check>**Consent timestamps** recorded and auditable</Check>
<Check>**Cookie consent** for tracking (where applicable)</Check>
<Check>**Privacy policy** link in all emails</Check>
<Check>**Data Processing Agreement** available for enterprise</Check>
<Check>**EU data residency** option (coming soon)</Check>

***

## CAN-SPAM Compliance (USA)

### What is CAN-SPAM?

**Controlling the Assault of Non-Solicited Pornography And Marketing Act** is US federal law regulating commercial email.

**Penalties:** Up to \$50,120 per violation

### CAN-SPAM Requirements

Migma helps you comply with all CAN-SPAM requirements:

<Steps>
  <Step title="Accurate Header Information">
    **Required:** From, To, and Reply-To must be accurate

    **Migma enforces:**

    * Verified sender domains
    * Accurate from names
    * Working reply-to addresses
    * No deceptive routing information
  </Step>

  <Step title="Non-Deceptive Subject Lines">
    **Required:** Subject must reflect email content

    **Examples:**

    * ✅ "25% Off Summer Sale - Ends Friday"
    * ❌ "Re: Your Order" (when there's no order)
    * ❌ "Urgent: Security Alert" (for marketing)

    **Migma's AI:** Helps generate accurate subjects
  </Step>

  <Step title="Identify as Advertisement">
    **Required for commercial emails**

    **Not always necessary if:**

    * Relationship exists
    * Content is transactional
    * Customer requested info

    **Migma includes:**

    * Optional "Advertisement" disclosure
    * Configurable per campaign type
  </Step>

  <Step title="Physical Postal Address">
    **Required:** Valid physical address in every email

    **Migma automatically includes:**

    ```text theme={null}
    Your Company Name
    123 Main Street, Suite 100
    San Francisco, CA 94105
    ```

    **Configure once:** Settings → Compliance → Business Address

    **Where it appears:**

    * Email footer
    * Preference center
    * Unsubscribe page
  </Step>

  <Step title="Clear Unsubscribe Mechanism">
    **Required:**

    * Conspicuous unsubscribe option
    * Works for 30 days after sending
    * No fee, login, or additional info required

    **Migma provides:**

    * ✅ One-click unsubscribe link
    * ✅ 30+ day link validity
    * ✅ No login required
    * ✅ Instant processing
    * ✅ Confirmation message

    **Automatically in every email footer**
  </Step>

  <Step title="Honor Opt-Out Requests">
    **Required:** Process unsubscribes within 10 business days

    **Migma processing:**

    * ⚡ **Instant:** Unsubscribes processed immediately
    * ✅ No emails sent after opt-out
    * 📝 Opt-out list maintained
    * 🔒 Cannot sell/transfer opt-out list
  </Step>

  <Step title="Monitor Third Parties">
    **Required:** Responsible for all email sent on your behalf

    **If using agencies/contractors:**

    * Ensure they comply with CAN-SPAM
    * Monitor their sending practices
    * You're liable for violations

    **Migma helps:**

    * User permission system
    * Audit logs of all sends
    * Agency access controls
  </Step>
</Steps>

### CAN-SPAM Compliance Checklist

Before sending marketing emails:

<Check>From address is accurate and yours</Check>
<Check>Subject line reflects email content</Check>
<Check>Physical address in footer</Check>
<Check>Clear unsubscribe link</Check>
<Check>Unsubscribe works immediately</Check>
<Check>No deceptive headers or routing</Check>

**Migma automatically handles most of these!**

***

## CASL Compliance (Canada)

### What is CASL?

**Canada's Anti-Spam Legislation** is stricter than CAN-SPAM.

**Key differences:**

* **Opt-in required** (vs opt-out in CAN-SPAM)
* **Express or implied consent** needed before sending
* **Penalties:** Up to \$10 million CAD per violation

### CASL Requirements

<Tabs>
  <Tab title="Consent">
    **Must have consent before sending**

    **Express consent:**

    * Explicit opt-in checkbox
    * Clear what they're consenting to
    * Valid for perpetuity (until withdrawn)

    **Implied consent (expires after 2 years):**

    * Existing business relationship
    * Inquiry or application within 6 months
    * Membership/volunteer relationship

    **Migma tracks:**

    * Consent date and source
    * Type of consent (express/implied)
    * Consent expiration (for implied)
  </Tab>

  <Tab title="Identification">
    **Must identify sender clearly**

    **Required in every email:**

    * Your name/business name
    * Physical mailing address
    * Contact information (phone, email, or web)

    **Migma includes:**

    * Company name in header/footer
    * Physical address
    * Contact info
  </Tab>

  <Tab title="Unsubscribe">
    **Must provide easy unsubscribe**

    **Requirements:**

    * Free
    * Functional for 60 days (vs 30 for CAN-SPAM)
    * Processed within 10 business days

    **Migma provides:**

    * One-click unsubscribe
    * 90-day link validity
    * Instant processing
  </Tab>
</Tabs>

### CASL Features in Migma

<Check>**Checkbox consent** tracking (express)</Check>
<Check>**Consent timestamps** and source</Check>
<Check>**Consent expiration** warnings (implied)</Check>
<Check>**Canadian compliance** mode toggle</Check>

***

## Other International Regulations

### EU ePrivacy (Cookie Law)

**Requires consent for cookies and tracking**

**Migma's tracking:**

* Email open tracking (pixel)
* Link click tracking
* Analytics cookies (website)

**Compliance:**

* Preference center includes tracking consent
* Can disable tracking per subscriber
* Cookie consent banner (for web)

### Australian Spam Act

**Similar to CAN-SPAM but requires:**

* Consent (opt-in)
* Clear unsubscribe
* Accurate sender info

**Migma supports:** All requirements via settings

### PECR (UK)

**Privacy and Electronic Communications Regulations**

**Requirements:**

* Consent for marketing emails
* Exceptions for existing customers
* Clear unsubscribe

**Migma compliance:** Same as GDPR + consent tracking

***

## Security Features

### Encryption

<AccordionGroup>
  <Accordion title="Data in Transit" icon="arrow-right-arrow-left">
    **All data encrypted during transmission:**

    ✅ **TLS 1.3** for all connections

    * API requests
    * Web interface
    * Email sending
    * Database connections

    ✅ **HTTPS enforced**

    * Automatic redirect from HTTP
    * HSTS headers
    * Perfect forward secrecy
  </Accordion>

  <Accordion title="Data at Rest" icon="database">
    **All data encrypted when stored:**

    ✅ **AES-256 encryption**

    * Database (MongoDB encrypted)
    * File storage (S3 encrypted)
    * Backups (encrypted at rest)

    ✅ **Key management**

    * Separate encryption keys per customer (enterprise)
    * Regular key rotation
    * Hardware security modules (HSMs)
  </Accordion>
</AccordionGroup>

### Authentication & Access Control

<Tabs>
  <Tab title="User Authentication">
    **Secure login:**

    ✅ **Password requirements**

    * Minimum 12 characters
    * Complexity requirements
    * No common passwords
    * Password hashing (bcrypt)

    ✅ **Multi-factor authentication (MFA)**

    * TOTP authenticator apps
    * SMS backup codes
    * Enforce for all users (enterprise)

    ✅ **Session management**

    * Secure session tokens
    * Automatic timeout
    * Device tracking
  </Tab>

  <Tab title="Role-Based Access">
    **Team permissions:**

    **Roles:**

    * **Owner:** Full access
    * **Admin:** Most features
    * **Editor:** Create/edit emails
    * **Viewer:** Read-only

    **Permissions:**

    * Granular control per feature
    * Audit log of all actions
    * Can't escalate own permissions
  </Tab>

  <Tab title="API Security">
    **Secure API access:**

    ✅ **API keys**

    * Unique per project
    * Scoped permissions
    * Rotatable
    * Revocable

    ✅ **Rate limiting**

    * Prevent abuse
    * DDoS protection
    * Per-key limits

    ✅ **IP allowlisting** (enterprise)

    * Restrict API access by IP
    * Multiple IPs supported
  </Tab>
</Tabs>

### Infrastructure Security

<Check>**SOC 2 Type II audited infrastructure**</Check>
<Check>**Regular penetration testing** (quarterly)</Check>
<Check>**Vulnerability scanning** (continuous)</Check>
<Check>**DDoS protection** (Cloudflare)</Check>
<Check>**WAF (Web Application Firewall)**</Check>
<Check>**Intrusion detection** (automated)</Check>

### Application Security

<Check>**Input validation** on all user input</Check>
<Check>**XSS protection** (content sanitization)</Check>
<Check>**CSRF tokens** on all forms</Check>
<Check>**SQL injection prevention** (parameterized queries)</Check>
<Check>**Dependency scanning** (automated updates)</Check>
<Check>**Code review** before deployment</Check>

***

## Privacy Features

### Data Processing Agreement (DPA)

**For GDPR compliance:**

Enterprise customers receive a DPA covering:

* Scope of processing
* Data protection obligations
* Sub-processors
* Data subject rights
* Security measures
* Breach notification

**Request DPA:** [enterprise@migma.ai](mailto:enterprise@migma.ai)

### Subprocessors

**Third-party services Migma uses:**

| Service | Purpose | Location |
| - | - | - |
| AWS | Hosting & infrastructure | USA |
| MongoDB Atlas | Database | USA |
| Anthropic | AI models | USA |
| Stripe | Payment processing | USA |
| Cloudflare | CDN & security | Global |

**Enterprise customers:** Can request dedicated infrastructure or data residency options.

### Data Residency

**Current:** Data stored in US (AWS us-east-1)

**Coming soon:**

* ✅ EU data residency option
* ✅ UK data residency option
* ✅ Customer-specified regions (enterprise)

***

## Incident Response

### Security Incident Process

<Steps>
  <Step title="Detection">
    **Automated monitoring:**

    * Intrusion detection
    * Anomaly detection
    * Alert systems
  </Step>

  <Step title="Assessment">
    **Within 1 hour:**

    * Classify severity
    * Identify scope
    * Determine impact
  </Step>

  <Step title="Containment">
    **Immediate actions:**

    * Isolate affected systems
    * Block malicious activity
    * Prevent spread
  </Step>

  <Step title="Notification">
    **If personal data affected:**

    * Customers notified within 72 hours
    * Authorities notified (if required)
    * Transparent communication
  </Step>

  <Step title="Remediation">
    **Fix and recover:**

    * Patch vulnerabilities
    * Restore from backups
    * Enhanced monitoring
  </Step>

  <Step title="Post-Incident">
    **Learn and improve:**

    * Root cause analysis
    * Update procedures
    * Additional safeguards
  </Step>
</Steps>

### Breach Notification

**If your data is compromised:**

* Email notification within 72 hours
* Details of what happened
* Data affected
* Steps taken
* Your recommended actions

**GDPR requirement:** 72-hour notification to authorities

***

## Audit & Logging

### Audit Logs

**Migma logs all significant actions:**

<Check>User logins and logouts</Check>
<Check>Email creation and edits</Check>
<Check>Email sends</Check>
<Check>Subscriber additions/deletions</Check>
<Check>Setting changes</Check>
<Check>Team member actions</Check>
<Check>API calls</Check>

**Retention:** 1 year (enterprise: 7 years)

**Access:** Settings → Audit Logs

### Compliance Reporting

**Enterprise features:**

* Downloadable compliance reports
* Activity summaries
* User access reports
* Data processing records

***

## Best Practices

<AccordionGroup>
  <Accordion title="Use Double Opt-In (EU)" icon="envelope-circle-check">
    **For GDPR compliance:**

    1. User signs up
    2. Confirmation email sent
    3. User clicks confirm link
    4. Subscription activated

    **Migma setting:**
    Settings → Compliance → Double Opt-In: ON
  </Accordion>

  <Accordion title="Keep Records" icon="file-lines">
    **Document everything:**

    * When consent obtained
    * How consent obtained
    * What they consented to
    * IP address (optional)
    * Timestamp

    **Migma tracks automatically**
  </Accordion>

  <Accordion title="Regular Compliance Review" icon="calendar-check">
    **Quarterly checklist:**

    * Review privacy policy (still accurate?)
    * Check unsubscribe links (working?)
    * Verify physical address (current?)
    * Test preference center (functional?)
    * Review retained data (still needed?)
  </Accordion>

  <Accordion title="Train Your Team" icon="chalkboard-user">
    **Ensure team knows:**

    * Privacy requirements
    * How to handle data requests
    * What not to do with subscriber data
    * Breach reporting procedures
  </Accordion>
</AccordionGroup>

***

## Intellectual Property & Prohibited Uses

### Protection of Proprietary Systems

**Migma's proprietary technology is protected by intellectual property laws.**

<Warning>
  **Strictly Prohibited Activities:**

  The following actions are expressly forbidden and constitute violations of our Terms of Service:

  * ❌ **Extracting, copying, or reverse-engineering** our AI model instructions, prompts, or system configurations
  * ❌ **Scraping, harvesting, or systematically collecting** emails, templates, or content from the platform
  * ❌ **Reproducing or redistributing** our proprietary algorithms, workflows, or technical implementations
  * ❌ **Using extracted content for commercial purposes** including training competing AI models
  * ❌ **Sharing, selling, or licensing** any proprietary Migma technology or content to third parties
  * ❌ **Automated data extraction** via bots, scrapers, or unauthorized API usage
</Warning>

### Intellectual Property Rights

**What Migma owns:**

<AccordionGroup>
  <Accordion title="Proprietary Technology" icon="microchip">
    **Protected intellectual property includes:**

    ✅ **AI model instructions and prompts**

    * System prompts and configurations
    * Model fine-tuning and training data
    * Prompt engineering techniques
    * AI workflow architectures

    ✅ **Platform technology**

    * Source code and algorithms
    * Database schemas and structures
    * API implementations
    * User interface designs

    ✅ **Proprietary methodologies**

    * Email generation processes
    * Image-to-email conversion algorithms
    * Figma import technology
    * Content optimization systems

    **Legal protection:** Copyright, trade secret, and patent laws
  </Accordion>

  <Accordion title="User-Generated Content" icon="user-pen">
    **Your content ownership:**

    ✅ **You retain ownership of:**

    * Your email content and copy
    * Your uploaded images and assets
    * Your subscriber lists and data
    * Your brand materials

    ✅ **License you grant Migma:**

    * Limited license to process and display your content
    * Only for providing the service to you
    * Revocable upon account deletion
    * Non-transferable to third parties

    ✅ **What we don't do:**

    * Claim ownership of your content
    * Use your content for other customers
    * Sell or license your content
    * Train models on your private content (without consent)
  </Accordion>

  <Accordion title="Platform-Generated Content" icon="wand-magic-sparkles">
    **AI-generated content rights:**

    **Content created by Migma's AI:**

    * You receive a license to use commercially
    * Migma retains underlying technology rights
    * You cannot extract or reverse-engineer the generation process
    * You cannot claim the AI system as your own

    **Example:**

    * ✅ Use AI-generated email in your campaigns
    * ✅ Modify and customize AI output
    * ❌ Extract prompts used to generate content
    * ❌ Replicate our AI generation system
  </Accordion>
</AccordionGroup>

### Enforcement & Violations

**We actively monitor for violations:**

<Steps>
  <Step title="Detection">
    **Automated monitoring for:**

    * Unusual API usage patterns
    * Systematic data extraction attempts
    * Unauthorized access to system internals
    * Suspicious account activity
  </Step>

  <Step title="Investigation">
    **Upon detection:**

    * Account flagged for review
    * Activity logs analyzed
    * Scope of violation assessed
    * Evidence documented
  </Step>

  <Step title="Enforcement Actions">
    **Depending on severity:**

    **Minor violations:**

    * Warning notification
    * Temporary access restrictions
    * Mandatory compliance review

    **Serious violations:**

    * Immediate account suspension
    * Permanent account termination
    * Legal action for damages
    * Criminal referral (if applicable)
  </Step>

  <Step title="Legal Remedies">
    **We reserve the right to:**

    * Seek injunctive relief
    * Pursue monetary damages
    * Report to law enforcement
    * Pursue criminal charges for theft of trade secrets
  </Step>
</Steps>

### Penalties for Violations

<Warning>
  **Legal consequences may include:**

  💰 **Financial penalties:**

  * Statutory damages up to \$150,000 per work (copyright)
  * Actual damages plus profits from misuse
  * Attorney fees and court costs
  * Punitive damages for willful violations

  ⚖️ **Civil liability:**

  * Breach of contract claims
  * Misappropriation of trade secrets
  * Unfair competition
  * Tortious interference

  🚨 **Criminal liability:**

  * Trade secret theft (up to 10 years imprisonment)
  * Computer fraud and abuse
  * Wire fraud
  * Copyright infringement
</Warning>

### Acceptable Use Policy

**What you CAN do:**

<Check>Use Migma to create and send your email campaigns</Check>
<Check>Export your own subscriber data and content</Check>
<Check>Integrate via official API with proper authentication</Check>
<Check>Share publicly available documentation and guides</Check>
<Check>Provide feedback and feature suggestions</Check>
<Check>Use AI-generated content in your business</Check>

**What you CANNOT do:**

<Check>❌ Reverse-engineer our AI models or prompts</Check>
<Check>❌ Scrape or systematically download platform content</Check>
<Check>❌ Share or resell access to Migma technology</Check>
<Check>❌ Use extracted data to build competing products</Check>
<Check>❌ Circumvent security or access controls</Check>
<Check>❌ Violate rate limits or terms of service</Check>

### Reporting Violations

**If you discover misuse of Migma's intellectual property:**

<Card title="Report IP Violations" icon="shield-exclamation" href="mailto:legal@migma.ai">
  **Email:** [legal@migma.ai](mailto:legal@migma.ai)

  **Include:**

  * Description of the violation
  * Evidence (URLs, screenshots, etc.)
  * Your contact information
  * Date and time of discovery

  **We investigate all reports within 48 hours**
</Card>

### Third-Party Compliance

**If you're building integrations or using our API:**

<AccordionGroup>
  <Accordion title="API Usage Requirements" icon="plug">
    **Authorized API use only:**

    ✅ **Required:**

    * Valid API key with proper scopes
    * Respect rate limits
    * Follow API documentation
    * Proper attribution where required

    ❌ **Prohibited:**

    * Sharing API keys
    * Exceeding rate limits
    * Undocumented API endpoints
    * Automated account creation
  </Accordion>

  <Accordion title="Integration Guidelines" icon="diagram-project">
    **Building on Migma:**

    ✅ **Allowed:**

    * Official API integrations
    * Zapier/Make.com workflows
    * Custom internal tools
    * Documented webhook usage

    ❌ **Not allowed:**

    * Screen scraping
    * Unofficial API access
    * Bypassing authentication
    * Extracting proprietary logic
  </Accordion>

  <Accordion title="Reseller/Agency Rules" icon="handshake">
    **If you're an agency or reseller:**

    ✅ **You may:**

    * Manage client accounts (with permission)
    * Create campaigns for clients
    * Provide training and support
    * Charge for your services

    ❌ **You may not:**

    * Resell Migma access without authorization
    * White-label Migma as your own product
    * Share proprietary Migma technology
    * Claim ownership of Migma features
  </Accordion>
</AccordionGroup>

### Data Protection for Proprietary Content

**How we protect our intellectual property:**

<Tabs>
  <Tab title="Technical Measures">
    **Security controls:**

    * 🔒 Encrypted system prompts and configurations
    * 🔐 Access controls on proprietary code
    * 🛡️ Rate limiting and abuse detection
    * 📊 Monitoring and anomaly detection
    * 🚫 Obfuscation of sensitive algorithms
  </Tab>

  <Tab title="Legal Measures">
    **Legal protections:**

    * 📄 Terms of Service enforcement
    * 🔏 Non-disclosure agreements
    * ⚖️ Copyright and trademark registration
    * 🏛️ Trade secret protection
    * 📋 Patent applications (where applicable)
  </Tab>

  <Tab title="Contractual Measures">
    **Agreement requirements:**

    * ✍️ Acceptance of Terms of Service
    * 🤝 API usage agreements
    * 🔒 Confidentiality obligations
    * ⚠️ Violation consequences
    * 📜 Dispute resolution procedures
  </Tab>
</Tabs>

### Educational Use & Research

**Academic and research exceptions:**

<Info>
  **Limited exceptions for:**

  ✅ **Academic research:**

  * Must be non-commercial
  * Requires prior written approval
  * Proper attribution required
  * Results may be published with permission

  ✅ **Educational purposes:**

  * Classroom demonstrations (with license)
  * Student projects (non-commercial)
  * Training materials (authorized only)

  **Contact:** [research@migma.ai](mailto:research@migma.ai) for approval
</Info>

***

## Need Help?

<CardGroup>
  <Card title="Privacy Policy" icon="file-contract" href="https://migma.ai/privacy">
    Read our privacy policy
  </Card>

  <Card title="Terms of Service" icon="handshake" href="https://migma.ai/terms">
    Review terms of service
  </Card>

  <Card title="Contact Privacy Team" icon="envelope" href="mailto:privacy@migma.ai">
    [privacy@migma.ai](mailto:privacy@migma.ai)
  </Card>

  <Card title="Enterprise Security" icon="building" href="mailto:enterprise@migma.ai">
    Get SOC 2 report
  </Card>
</CardGroup>


# Migma MCP Security for IT Administrators
Source: https://docs.migma.ai/security/mcp

Review how the hosted Migma MCP server works, what each permission allows, how browser OAuth protects access, and how IT admins can revoke connections.

Use this page when an IT or security reviewer is deciding whether to approve the Migma plugin in ChatGPT or Grok Bot, a custom connector in Claude, or another MCP client.

This is not a setup guide. For connection steps, see [ChatGPT](/agents/mcp-chatgpt), [Claude](/agents/mcp-claude), or [MCP Server](/mcp-server).

## What Migma MCP does

Migma is an AI email marketer. The hosted MCP server lets a signed-in person use ChatGPT, Claude, or another MCP client to work in their Migma account.

With an approved connection, the client can:

* Prepare on-brand email drafts and show previews
* Import contacts and manage lists or segments
* Save lasting brand facts
* Prepare campaign drafts and read campaign stats
* Export reviewed emails to HTML or connected tools such as Klaviyo, Mailchimp, or HubSpot
* Send test or live email only when send permission is granted

Migma is for permission-based email, not cold outreach. See [Sending rules](/get-started/what-you-can-send).

## How sign-in works

Hosted MCP URL:

```text theme={null}
https://migma.ai/mcp
```

Add only that URL. The client opens Migma in the browser. A signed-in Migma user reviews the app name, return host, and requested permissions, then approves or denies access at `migma.ai/connect/authorize`.

Hosted MCP does not ask you to paste an API key. After approval, Migma creates a connection key automatically. That key appears in **Settings → Developers → API Keys**.

Hosted sign-in usually requests the full Migma API permission set so the client can use the matching tools. `email:send` permits test/direct sends. `campaign:write` permits campaign creation, send, and schedule. Migma marks both groups as delivery access. Deny the connection if your policy does not allow this client to send.

ChatGPT, Claude, and similar products may also require a workspace admin to allow plugins, apps, or custom MCP connectors. That is the client's policy. Migma still requires a signed-in Migma user to consent before the connector can call Migma.

## Permissions

MCP uses the same permission names as the Migma API. A granted permission allows the matching API actions, not extra access.

| Permission | What it allows |
| - | - |
| `email:read` | View emails and sending history |
| `email:write` | Prepare and edit email drafts |
| `email:send` | Send test and live emails. Destructive. |
| `email:validate` | Run compatibility, link, and deliverability checks |
| `email:preview` | Generate device and inbox previews |
| `audience:read` | View contacts, lists, and segments |
| `audience:write` | Add or update contacts, lists, and segments |
| `campaign:read` | View campaigns, stats, and delivery logs |
| `campaign:write` | Create, schedule, send, and manage campaigns |
| `domain:read` | View sending domains, verification and purchase status, and custom DNS on domains bought in Migma |
| `domain:write` | Add, verify, update, or remove sending domains; buy a domain (Stripe checkout the account owner opens); manage custom DNS on domains bought in Migma |
| `billing:read` | View plan and credits |
| `billing:write` | Create Stripe checkout or billing portal links the account owner opens and approves |
| `project:write` | Import brands and update brand resources |
| `webhook:read` | View webhooks |
| `webhook:write` | Create, update, or delete webhooks |

Full list: [Authentication](/authentication).

<Warning>
  `email:send` allows test and live sends through the connected account. `campaign:write` can also send or schedule campaigns. Only allow those permissions if you trust this client to send for you.
</Warning>

## Data and access

* The connection has the same reach as a Migma API key with those permissions. Treat MCP like direct API access, not a separate broader integration.
* It can act on brands in the signed-in Migma account. API and data contracts use `project` / `projectId` for a brand.
* Migma returns the account data or action result needed for each tool call. Authentication tokens are not included in normal tool results.
* The MCP client (for example ChatGPT or Claude) processes conversation text and tool inputs or results under that vendor's terms. See [Privacy Policy](/legal/privacy-policy).
* Send, campaign, export, and audience-changing tools are marked as writes or as destructive. Clients that honor those hints typically ask the person before running them. Treat either `email:send` or `campaign:write` as send capability.
* Keep a human in the loop before live sends, exports, audience changes, and campaign sends.
* Sending through Migma must follow [acceptable use](/legal/acceptable-use) and [sending rules](/get-started/what-you-can-send).

## Revoke access

1. Open [migma.ai](https://migma.ai) and go to **Settings → Developers → API Keys**.
2. Find the key created for the ChatGPT, Claude, or other MCP connection.
3. Delete the key and confirm.

Revoking invalidates that key. Reconnect or restart the MCP client so it stops using the old connection.

## Related pages

<CardGroup>
  <Card title="ChatGPT setup" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/chatgpt.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=f88137fa5b3adadac975427b68304728" href="/agents/mcp-chatgpt">
    Use the public plugin or custom MCP fallback. Visual steps: [ChatGPT tutorial](/tutorials/connect-migma-to-chatgpt).
  </Card>

  <Card title="Claude setup" icon="https://mintcdn.com/migmaai/kT6TJgF40rDP8_qB/images/logos/claude-code.png?fit=max&auto=format&n=kT6TJgF40rDP8_qB&q=85&s=21dc5dcc66f09660a16fbea3297333b4" href="/agents/mcp-claude">
    Connect Claude.ai, Claude Code, or Claude Desktop.
  </Card>

  <Card title="Grok setup" icon="https://mintcdn.com/migmaai/D0Z-B44phiLBOsYh/images/logos/grok-bot.webp?fit=max&auto=format&n=D0Z-B44phiLBOsYh&q=85&s=3154724e3ec13fdf760e0b3cc4225509" href="/grok">
    Compare Grok Bot, Grok custom connector, and Grok Build.
  </Card>

  <Card title="MCP Server" icon="server" href="/mcp-server">
    Hosted and local MCP connection details.
  </Card>

  <Card title="Security & compliance" icon="shield" href="/security/compliance">
    SOC 2, GDPR, and email-law guidance.
  </Card>

  <Card title="Sending rules" icon="envelope-circle-check" href="/get-started/what-you-can-send">
    Permission-based email. No cold outreach.
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    API permissions and how to revoke keys.
  </Card>
</CardGroup>


# Add DNS Records
Source: https://docs.migma.ai/sending-domains/add-dns-records

After you add a custom sending domain, Migma gives you DNS records for ownership, DKIM, SPF, DMARC, and the custom MAIL FROM return path.

## Overview

After you add a custom sending domain, Migma gives you DNS records for ownership, DKIM, SPF, DMARC, and the custom MAIL FROM return path. Add those records wherever your domain's nameservers are managed.

<Note>
  Migma sending domains are for permission-based email. Only send to people who expect email from your brand, and review [what you can send](/get-started/what-you-can-send) before sending campaigns.
</Note>

***

## Before you start

You need:

* Access to your DNS provider, such as Cloudflare, Route 53, GoDaddy, Namecheap, Squarespace, Wix, or another host
* The Migma **Sending Domains** page open in another tab
* The exact domain you want to send from, often a sending subdomain such as `mail.yourcompany.com` or `updates.yourcompany.com`

<Tip>
  Using a sending subdomain is common because it keeps campaign reputation separate from your main website and day-to-day inbox domain.
</Tip>

***

## Step 1: Add the domain in Migma

<Steps>
  <Step title="Open Sending Domains">
    In Migma, go to **Sending Domains**.
  </Step>

  <Step title="Choose Custom Domain">
    Click **Add Domain**, choose **Custom**, then enter the domain you want to send from.

    Examples:

    * `yourcompany.com`
    * `mail.yourcompany.com`
    * `updates.yourcompany.com`
  </Step>

  <Step title="Add the domain">
    Add the domain. Migma automatically assigns the sending region.
  </Step>
</Steps>

<Frame>
  <img alt="Migma Add Domain dialog with the Custom tab selected" />
</Frame>

***

## Step 2: Open the DNS records

Migma shows every record you need to create. Keep this table open and copy each value directly.

<Frame>
  <img alt="Migma DNS records table for a custom sending domain" />
</Frame>

Most custom domains have 8 records:

| Purpose | Type | Where it goes |
| - | - | - |
| Ownership verification | TXT | The sending domain |
| DKIM authentication | CNAME | Three `_domainkey` hostnames |
| SPF sending authorization | TXT | The sending domain |
| DMARC policy | TXT | `_dmarc` under the sending domain |
| Custom MAIL FROM | MX | `send` under the sending domain |
| MAIL FROM SPF | TXT | `send` under the sending domain |

<Note>
  If Migma shows **Custom MAIL FROM not configured**, add both pending MAIL FROM records: the MX record and the TXT record. The MX record needs priority `10`.
</Note>

***

## Step 3: Translate the record name

DNS dashboards usually ask for a **Name**, **Host**, or **Record name**. This is the part most often entered incorrectly.

Use the name Migma shows, but make it relative to the DNS zone you are editing if your provider auto-appends the zone.

| Migma record name | DNS zone you are editing | Enter this name |
| - | - | - |
| `mail.example.com` | `example.com` | `mail` |
| `_dmarc.mail.example.com` | `example.com` | `_dmarc.mail` |
| `send.mail.example.com` | `example.com` | `send.mail` |
| `send.mail.example.com` | `mail.example.com` | `send` |
| `example.com` | `example.com` | `@` or leave blank, depending on provider |

<Warning>
  Do not create `send` on the wrong zone. `send.mail-eu.example.com` and `send.mail-us.example.com` are different hostnames even though both can appear as `send` when you are editing separate delegated zones.
</Warning>

***

## Step 4: Add each record at your DNS provider

Create one DNS record for each row shown in Migma.

<Steps>
  <Step title="Add the ownership TXT record">
    Create a TXT record with the Migma verification value, such as `migma-verify=...`.
  </Step>

  <Step title="Add the three DKIM CNAME records">
    Create all three CNAME records. The names contain `_domainkey`, and the targets end in `dkim.amazonses.com`.

    In Cloudflare, set DKIM CNAME records to **DNS only**. Do not proxy them.
  </Step>

  <Step title="Add the SPF TXT record">
    Create or edit the SPF TXT record for the sending domain.

    If there is no SPF record yet:

    ```txt theme={null}
    v=spf1 include:spf.migma.ai ~all
    ```

    If the domain already has SPF, keep one SPF TXT record and add Migma before the final mechanism:

    ```txt theme={null}
    v=spf1 include:_spf.google.com include:spf.migma.ai ~all
    ```
  </Step>

  <Step title="Add the DMARC TXT record">
    Create the `_dmarc` TXT record exactly as Migma shows it.

    ```txt theme={null}
    v=DMARC1; p=quarantine; rua=mailto:dmarc@migma.ai
    ```
  </Step>

  <Step title="Add the MAIL FROM MX record">
    Create the MX record for the MAIL FROM hostname, usually `send` under your sending domain.

    * Priority: `10`
    * Mail server: copy the Migma value, such as `feedback-smtp.eu-west-1.amazonses.com`
  </Step>

  <Step title="Add the MAIL FROM SPF TXT record">
    Create the TXT record on the same MAIL FROM hostname.

    ```txt theme={null}
    v=spf1 include:spf.migma.ai ~all
    ```
  </Step>
</Steps>

<Tip>
  For TXT values, most DNS dashboards add quotes automatically. Paste the text value without surrounding quotes unless your provider specifically requires quoted TXT strings.
</Tip>

***

## Provider field guide

<Tabs>
  <Tab title="Cloudflare">
    1. Open Cloudflare and select your zone.
    2. Go to **DNS** -> **Records**.
    3. Click **Add record**.
    4. Copy the record type, name, and value from Migma.
    5. For DKIM CNAME records, set **Proxy status** to **DNS only**.
    6. Leave TTL as **Auto**.

    Cloudflare may display full names after saving. That is normal as long as the resolved hostname matches the Migma record.

    Reference: [Cloudflare DNS record guide](https://developers.cloudflare.com/dns/manage-dns-records/how-to/create-dns-records/)
  </Tab>

  <Tab title="Route 53">
    1. Open the Route 53 console.
    2. Go to **Hosted zones** and choose the hosted zone for your domain.
    3. Click **Create record**.
    4. Choose the type Migma shows.
    5. Enter the record name relative to the hosted zone.
    6. For MX, put priority `10` before the mail server if the UI uses one value field, or use the separate priority field if shown.

    Reference: [Route 53 create records guide](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-creating.html)
  </Tab>

  <Tab title="GoDaddy">
    1. Open your GoDaddy Domain Portfolio.
    2. Select the domain, then open **DNS**.
    3. Click **Add New Record**.
    4. Use GoDaddy's **Name** field for the host prefix, without the domain name.
    5. Use `@` only when the record is at the zone root.
    6. Save each TXT, CNAME, and MX record from Migma.

    Reference: [GoDaddy TXT record guide](https://www.godaddy.com/help/add-a-txt-record-19232)
  </Tab>

  <Tab title="Namecheap">
    1. Open **Domain List** in Namecheap.
    2. Click **Manage** for the domain.
    3. Open **Advanced DNS**.
    4. In **Host Records**, click **Add New Record**.
    5. Enter the host prefix in **Host**. Use `@` only for the zone root.
    6. Save all Migma records.

    Reference: [Namecheap TXT, SPF, DKIM, and DMARC guide](https://www.namecheap.com/support/knowledgebase/article.aspx/317/2237/how-do-i-add-txtspfdkimdmarc-records-for-my-domain/)
  </Tab>
</Tabs>

***

## Step 5: Verify in Migma

After saving the DNS records, return to Migma and check the domain.

<Steps>
  <Step title="Wait a few minutes">
    Most DNS providers publish updates within 5-60 minutes. Some records can take longer.
  </Step>

  <Step title="Open the domain menu">
    In **Sending Domains**, open the action menu for the domain.
  </Step>

  <Step title="Click Check DNS">
    Migma checks each record and updates the status.
  </Step>
</Steps>

<Frame>
  <img alt="Migma sending domain action menu with Check DNS" />
</Frame>

***

## Common issues

<AccordionGroup>
  <Accordion title="The provider added the domain twice" icon="copy">
    This usually means the full record name was pasted into a field that expected only the host prefix.

    Example problem: entering `send.mail.example.com` in the `example.com` zone creates `send.mail.example.com.example.com`.

    Fix it by changing the name to `send.mail`.
  </Accordion>

  <Accordion title="SPF has duplicate TXT records" icon="shield">
    A domain should have one TXT record that starts with `v=spf1`. If one already exists, edit it and add `include:spf.migma.ai` before `~all` or `-all`.
  </Accordion>

  <Accordion title="DKIM CNAME records are proxied" icon="cloud">
    In Cloudflare, DKIM CNAME records must be **DNS only**. Email authentication records cannot use the orange proxy cloud.
  </Accordion>

  <Accordion title="MAIL FROM is still pending" icon="envelope">
    Check both MAIL FROM records. The MX record and TXT record must use the same hostname, usually `send` under the sending domain.

    Amazon SES requires the custom MAIL FROM domain to have exactly one MX record for that hostname. If another service already owns that hostname, remove the old record or use a different sending domain.
  </Accordion>

  <Accordion title="You are editing the wrong DNS provider" icon="signs-post">
    Your registrar is not always your DNS host. Check your nameservers, then add Migma records at the provider listed there.
  </Accordion>
</AccordionGroup>

***

## References

These provider docs informed the field labels and DNS-entry rules in this tutorial:

* [Cloudflare: create DNS records](https://developers.cloudflare.com/dns/manage-dns-records/how-to/create-dns-records/)
* [Amazon Route 53: create records in the console](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-creating.html)
* [Amazon SES: custom MAIL FROM domains](https://docs.aws.amazon.com/ses/latest/dg/mail-from.html)
* [GoDaddy: add a TXT record](https://www.godaddy.com/help/add-a-txt-record-19232)
* [Namecheap: add TXT, SPF, DKIM, and DMARC records](https://www.namecheap.com/support/knowledgebase/article.aspx/317/2237/how-do-i-add-txtspfdkimdmarc-records-for-my-domain/)
* [Resend: managing sending domains](https://resend.com/docs/dashboard/domains/introduction)


# Add a Domain
Source: https://docs.migma.ai/sending-domains/add-domain

Add a sending domain before production sends. Use a domain you own, buy a new one, or start with a Migma managed address for testing.

Add a sending domain before production sends. Use a domain you own, buy a new one, or start with a Migma managed address for testing.

## Setup paths

<CardGroup>
  <Card title="Use my domain" icon="globe">
    Connect a domain you own. Migma prepares DNS records and opens one-click setup through Entri when available.
  </Card>

  <Card title="Buy a domain" icon="credit-card" href="/sending-domains/buy-domain">
    Register a new domain from Migma and let Migma prepare sending setup.
  </Card>

  <Card title="Start with a Migma address" icon="bolt">
    Create a `migma.email` sending address without DNS.
  </Card>
</CardGroup>

## Use my domain

<Steps>
  <Step title="Open Sending Domains">
    Go to **Sending Domains** and click **Add Domain**.
  </Step>

  <Step title="Choose Use my domain">
    Enter your domain, such as `yourdomain.com` or `mail.yourdomain.com`.
  </Step>

  <Step title="Set up DNS">
    Use Entri one-click setup when shown, Cloudflare sign-in when available, or copy records manually.
  </Step>

  <Step title="Verify">
    Return to Migma and click **Verify**. DNS can take minutes to propagate.
  </Step>
</Steps>

<Tip>
  Sending subdomains such as `mail.yourdomain.com` or `updates.yourdomain.com` help isolate campaign reputation.
</Tip>

## Start with a Migma address

Use this path when you need a test sender or API sender now.

<Steps>
  <Step title="Open Add Domain">
    Go to **Sending Domains → Add Domain**.
  </Step>

  <Step title="Choose Start with a Migma address">
    Pick a prefix for `yourprefix.migma.email`.
  </Step>

  <Step title="Send">
    Migma verifies the managed domain instantly. Managed domains have stricter reputation limits than domains you own.
  </Step>
</Steps>

## After verification

* Send from any address at your verified domain, such as `hello@yourdomain.com`.
* Start [domain warming](/sending-domains/domain-warming) for a new domain you own. Managed Migma addresses use a fixed daily limit and do not warm.
* Review [domain settings](/sending-domains/domain-settings) before larger sends.

## Related guides

<CardGroup>
  <Card title="Buy a Domain" icon="credit-card" href="/sending-domains/buy-domain">
    Register a new sending domain from Migma.
  </Card>

  <Card title="Add DNS Records" icon="server" href="/sending-domains/add-dns-records">
    Copy DNS records into your provider.
  </Card>

  <Card title="Cloudflare DNS" icon="cloud" href="/sending-domains/cloudflare">
    Use Cloudflare setup for domains hosted there.
  </Card>

  <Card title="Verification Issues" icon="circle-question" href="/sending-domains/verification-issues">
    Fix records that stay pending or failed.
  </Card>
</CardGroup>


# Buy a Domain
Source: https://docs.migma.ai/sending-domains/buy-domain

Buy a domain when you need a new sender and do not already own the right domain. Migma registers it and prepares sending setup.

Buy a domain when you need a new sender and do not already own the right domain. Migma registers it and prepares sending setup.

<Frame>
  <img alt="Migma Add a sending domain dialog with options to use, buy, or start with a domain" />
</Frame>

## How it works

<Steps>
  <Step title="Open Sending Domains">
    Go to **Sending Domains → Add Domain**.
  </Step>

  <Step title="Choose Buy a domain">
    Use **Search for a domain** to enter a brand name or exact domain.
  </Step>

  <Step title="Pick a domain">
    Choose from **Available domains** and review annual billing.
  </Step>

  <Step title="Point the domain">
    Fill **Where should this domain point?** so visitors land on your site.
  </Step>

  <Step title="Buy domain">
    Click **Buy domain** and complete checkout.
  </Step>
</Steps>

<Warning>
  Domain purchases are billed annually and may be non-refundable once registered.
</Warning>

## What Migma handles

* Domain registration
* Sending setup
* DKIM, SPF, DMARC, and MAIL FROM authentication
* Domain status in **Sending Domains**

## Before you buy

* Choose a brand-safe domain users will recognize.
* Migma manages DNS for domains bought in Migma.
* Use [Add a Domain](/sending-domains/add-domain) if you already own the domain.
* Warm new domains before larger sends.

## Custom DNS records

Migma hosts DNS for domains bought in Migma, so there is no separate DNS panel. To manage the domain's records, open it in **Sending Domains**, go to the **DNS records** tab, and use **Custom DNS records**.

You can add and remove **A**, **AAAA**, **CNAME**, **MX**, **TXT**, and **NS** records at any name under your domain:

* Use **@** as the name for the root domain, or enter any name under it.
* **A** and **AAAA** point a subdomain at a server, for example `app.yourbrand.com`.
* **CNAME** points a name at another host, for service validation or hosted tools.
* **MX** lets the domain receive email through your inbox provider, such as Google Workspace or Microsoft 365.
* **TXT** covers verification checks: BIMI, Verified Mark Certificates, Microsoft 365, and Google Search Console.
* **NS** delegates a subdomain to another DNS provider.

A few records stay with Migma, because changing them would stop your email being delivered or authenticated:

* The records that power sending: SPF, DKIM, DMARC, the Return-Path records, and your domain's ownership record.
* A second SPF or DMARC record on a name that already has one. To authorize another sending service, add it to the existing SPF record.
* The root domain and **www** addresses, which **Domain forwarding** below controls.

Everything else goes through. If a value is not valid for its record type, the error explains what to fix.

## Domain forwarding

Visitors who open a bought domain in a browser are redirected to the address you chose at purchase. To change it, open the domain's **DNS records** tab and edit **Domain forwarding**.

## Related guides

<CardGroup>
  <Card title="Add a Domain" icon="plus" href="/sending-domains/add-domain">
    Connect a domain you already own.
  </Card>

  <Card title="Domain Warming" icon="fire" href="/sending-domains/domain-warming">
    Increase sending volume gradually.
  </Card>

  <Card title="What You Can Send" icon="shield-check" href="/get-started/what-you-can-send">
    Review permission-based sending rules.
  </Card>
</CardGroup>


# Cloudflare DNS
Source: https://docs.migma.ai/sending-domains/cloudflare

If your domain's DNS is managed on Cloudflare, you have three options for configuring DNS — from easiest to most manual.

## Overview

If your domain's DNS is managed on Cloudflare, you have three options for configuring DNS — from easiest to most manual.

***

## Option 1: Sign in to Cloudflare (One-Click)

The fastest option. Migma auto-detects that your domain uses Cloudflare DNS and handles everything for you — no API token needed.

<Steps>
  <Step title="Add Your Domain">
    Go to **Settings → Sending Domains → Add Domain** and enter the domain you want to send from, such as `yourdomain.com` or `mail.yourdomain.com`.
  </Step>

  <Step title="Click Sign in to Cloudflare">
    On the domain detail page, Migma detects Cloudflare DNS and shows a **Sign in to Cloudflare** button. Click it.
  </Step>

  <Step title="Authorize in Cloudflare">
    You're redirected to Cloudflare to authorize Migma. Review the permissions and click **Authorize**.
  </Step>

  <Step title="Done">
    You're redirected back to Migma. All DNS records are configured automatically and your domain begins verification.
  </Step>
</Steps>

<Note>
  **How this works:** Migma uses the Domain Connect protocol to configure DNS. No API token is created or stored — you simply authorize one-time access through Cloudflare's standard OAuth flow.

  **Prerequisite:** Your domain must be hosted on Cloudflare nameservers (not just using Cloudflare as a proxy).
</Note>

***

## Option 2: API Token Setup

If you prefer to use an API token (or the one-click flow isn't available for your setup), you can create a Cloudflare API token that lets Migma manage DNS records.

### Step 1: Add Your Domain to Migma

<Steps>
  <Step title="Open Sending Domains">
    Go to **Settings → Sending Domains** in your Migma dashboard.
  </Step>

  <Step title="Add Your Domain">
    Click **Add Domain** and enter your sending domain, for example `yourdomain.com` or `mail.yourdomain.com`.
  </Step>

  <Step title="View DNS Records">
    Migma displays the DNS records needed. Keep this page open.
  </Step>
</Steps>

### Step 2: Create a Cloudflare API Token

You need to create an API token that allows Migma to add DNS records.

<Steps>
  <Step title="Open Cloudflare API Tokens">
    Go to [dash.cloudflare.com/profile/api-tokens](https://dash.cloudflare.com/profile/api-tokens)
  </Step>

  <Step title="Click Create Token">
    Click the **Create Token** button.
  </Step>

  <Step title="Select Custom Token">
    Scroll down and click **Get started** next to **Create Custom Token**.
  </Step>

  <Step title="Name Your Token">
    Enter a name like `Migma DNS Access`.
  </Step>

  <Step title="Add Zone Read Permission">
    Under **Permissions**, click **Add more** and select:

    * **Zone** → **Zone** → **Read**
  </Step>

  <Step title="Add DNS Edit Permission">
    Click **Add more** again and select:

    * **Zone** → **DNS** → **Edit**
  </Step>

  <Step title="Set Zone Resources">
    Under **Zone Resources**, choose one of:

    | Option | When to Use |
    | - | - |
    | **Include → Specific zone → \[your domain]** | You only want Migma to access this one domain |
    | **Include → All zones** | You want Migma to manage DNS for any domain in your account |
  </Step>

  <Step title="Create the Token">
    Click **Continue to summary**, review the permissions, then click **Create Token**.
  </Step>

  <Step title="Copy the Token">
    **Important:** Copy the token immediately. It's only shown once.

    <Warning>
      If you lose the token, you'll need to create a new one.
    </Warning>
  </Step>
</Steps>

### Step 3: Connect Cloudflare to Migma

<Steps>
  <Step title="Return to Migma">
    Go back to **Settings → Sending Domains** and click on your domain.
  </Step>

  <Step title="Click Connect Cloudflare">
    Find the **Cloudflare Integration** section and click **Connect Cloudflare**.
  </Step>

  <Step title="Paste Your API Token">
    Paste the token you copied from Cloudflare.
  </Step>

  <Step title="Confirm Connection">
    Migma validates the token and shows the zones (domains) available.
  </Step>
</Steps>

### Step 4: Auto-Configure DNS

<Steps>
  <Step title="Click Auto-Configure DNS">
    Click the **Auto-configure DNS** button.
  </Step>

  <Step title="Review Records Added">
    Migma adds all required records to Cloudflare:

    * 3 DKIM CNAME records
    * 1 SPF TXT record
    * 1 DMARC TXT record
    * 2 MAIL FROM records (MX + TXT)
  </Step>

  <Step title="Verify Domain">
    Click **Verify Domain**. Verification typically completes within a few minutes.
  </Step>
</Steps>

***

## Option 3: Manual Setup

If you prefer to add DNS records manually in Cloudflare, follow these steps.

<Tip>
  For a provider-neutral walkthrough with screenshots, see [Add DNS Records](/sending-domains/add-dns-records).
</Tip>

### Step 1: Log in to Cloudflare

<Steps>
  <Step title="Go to Cloudflare Dashboard">
    Navigate to [dash.cloudflare.com](https://dash.cloudflare.com)
  </Step>

  <Step title="Select Your Domain">
    Click on the domain you want to configure.
  </Step>

  <Step title="Open DNS Settings">
    Click **DNS** in the left sidebar, then **Records**.
  </Step>
</Steps>

### Step 2: Add DKIM Records

Add 3 CNAME records for DKIM authentication.

<Steps>
  <Step title="Click Add Record">
    Click the **Add record** button.
  </Step>

  <Step title="Configure First DKIM Record">
    | Field | What to Enter |
    | - | - |
    | Type | Select `CNAME` |
    | Name | Copy the first `_domainkey` name from Migma (e.g., `abc123._domainkey`) |
    | Target | Copy the corresponding value from Migma |
    | Proxy status | Click to set to **DNS only** (gray cloud) |
    | TTL | Leave as `Auto` |

    Click **Save**.
  </Step>

  <Step title="Add Second DKIM Record">
    Repeat with the second set of values from Migma.
  </Step>

  <Step title="Add Third DKIM Record">
    Repeat with the third set of values from Migma.
  </Step>
</Steps>

<Warning>
  **Proxy status must be "DNS only" (gray cloud)**

  CNAME records for email authentication cannot be proxied through Cloudflare. If the cloud is orange, click it to turn it gray.
</Warning>

### Step 3: Add SPF Record

<Steps>
  <Step title="Check for Existing SPF">
    Look through your existing TXT records for one that starts with `v=spf1`.
  </Step>

  <Step title="Add or Modify SPF">
    **If you don't have an SPF record:**

    Click **Add record** and enter:

    | Field | What to Enter |
    | - | - |
    | Type | Select `TXT` |
    | Name | Enter `@` |
    | Content | `v=spf1 include:spf.migma.ai ~all` |
    | TTL | Leave as `Auto` |

    Click **Save**.

    ***

    **If you already have an SPF record:**

    Click **Edit** on your existing SPF record and add `include:spf.migma.ai` before the `~all`.

    Example:

    ```yaml theme={null}
    Before: v=spf1 include:_spf.google.com ~all
    After:  v=spf1 include:_spf.google.com include:spf.migma.ai ~all
    ```
  </Step>
</Steps>

### Step 4: Add DMARC Record

<Steps>
  <Step title="Add DMARC TXT Record">
    Click **Add record** and enter:

    | Field | What to Enter |
    | - | - |
    | Type | Select `TXT` |
    | Name | Enter `_dmarc` |
    | Content | `v=DMARC1; p=quarantine; rua=mailto:dmarc@migma.ai` |
    | TTL | Leave as `Auto` |

    Click **Save**.
  </Step>
</Steps>

### Step 5: Add MAIL FROM Records

Add both an MX record and a TXT record for the MAIL FROM subdomain. Copy the Name from Migma. If your sending domain is a subdomain and your Cloudflare zone is the parent domain, the Name may include that prefix, for example `send.mail-eu`.

<Steps>
  <Step title="Add MX Record">
    Click **Add record** and enter:

    | Field | What to Enter |
    | - | - |
    | Type | Select `MX` |
    | Name | Copy the MAIL FROM Name from Migma |
    | Mail server | Copy the value from Migma |
    | Priority | Enter `10` |
    | TTL | Leave as `Auto` |

    Click **Save**.
  </Step>

  <Step title="Add TXT Record for MAIL FROM">
    Click **Add record** and enter:

    | Field | What to Enter |
    | - | - |
    | Type | Select `TXT` |
    | Name | Copy the MAIL FROM Name from Migma |
    | Content | `v=spf1 include:spf.migma.ai ~all` |
    | TTL | Leave as `Auto` |

    Click **Save**.
  </Step>
</Steps>

### Step 6: Verify in Migma

<Steps>
  <Step title="Return to Migma">
    Go to **Settings → Sending Domains**.
  </Step>

  <Step title="Click Verify Domain">
    Click **Verify** next to your domain.
  </Step>

  <Step title="Wait for Verification">
    Verification typically completes within minutes. DKIM may take up to 72 hours in some cases.
  </Step>
</Steps>

***

## Managing Cloudflare Connection

### Disconnect Cloudflare

To remove the Cloudflare connection:

1. Go to **Settings → Sending Domains**
2. Click on your domain
3. Click **Disconnect Cloudflare**
4. Your DNS records remain in Cloudflare (they're not deleted)

### Delete DNS Records When Removing Domain

When you delete a domain from Migma:

1. If Cloudflare is connected, you'll see an option: **Also delete DNS records from Cloudflare**
2. Check this option to remove all email-related DNS records
3. Leave unchecked to keep the records (useful if migrating to another service)

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="Domain not found in your Cloudflare account" icon="magnifying-glass">
    **Possible causes:**

    * Your domain's DNS is not managed on Cloudflare
    * The API token doesn't have access to this zone

    **Solutions:**

    1. **Verify your domain is on Cloudflare:**
       * Log in to Cloudflare dashboard
       * Check if your domain appears in the account
       * Verify the domain status is "Active"

    2. **Check your API token permissions:**
       * Go to Cloudflare → Profile → API Tokens
       * Click "View" on your token to see which zones it can access
       * If using "Specific zone", ensure your domain is included

    3. **Create a new token with correct permissions:**
       * Create a new token with "All zones" to test
       * If that works, the original token was zone-restricted
  </Accordion>

  <Accordion title="Invalid API token" icon="key">
    **Possible causes:**

    * Token was copied incorrectly
    * Token was revoked or expired
    * Token doesn't have required permissions

    **Solutions:**

    1. Create a new token with the correct permissions:
       * Zone → Zone → Read
       * Zone → DNS → Edit

    2. Copy the token immediately after creation (it's only shown once)

    3. In Migma, click **Disconnect Cloudflare** and reconnect with the new token
  </Accordion>

  <Accordion title="DNS records not propagating" icon="clock">
    **What's happening:**
    Cloudflare updates are usually instant, but global DNS propagation takes time.

    **Timeline:**

    * Cloudflare: Instant
    * Global DNS: 5-60 minutes
    * DKIM verification: Up to 72 hours (rare cases)

    **What to do:**

    * Wait at least 15 minutes before retrying verification
    * Use [DNS Checker](https://dnschecker.org) to see if your records have propagated
  </Accordion>

  <Accordion title="Proxy status warning" icon="shield">
    **Issue:**
    CNAME records have orange cloud (proxied) instead of gray cloud (DNS only).

    **Why it matters:**
    Email authentication records cannot be proxied through Cloudflare. They must resolve directly.

    **Solution:**

    1. Go to Cloudflare DNS settings
    2. Find the DKIM CNAME records
    3. Click the orange cloud to turn it gray
  </Accordion>

  <Accordion title="Record already exists" icon="copy">
    **What happens:**
    If a DNS record with the same name and type already exists, Migma updates it instead of creating a duplicate.

    **This is normal and expected.** Your existing record is modified to include the correct values.
  </Accordion>
</AccordionGroup>

***

## Next Steps

<CardGroup>
  <Card title="Domain Settings" icon="gear" href="/sending-domains/domain-settings">
    Configure open and click tracking
  </Card>

  <Card title="Send to Audience" icon="paper-plane" href="/audience/sending-emails">
    Send your first email campaign
  </Card>
</CardGroup>


# Domain Health
Source: https://docs.migma.ai/sending-domains/domain-health

Migma monitors your domain health continuously based on two things: how many emails bounce and how many people mark your emails as spam.

Migma monitors your domain health continuously based on two things: how many emails bounce and how many people mark your emails as spam. If either gets too high, your domain can be suspended and sending will stop.

You can check your domain health at any time by going to **Sending Domains**, clicking on your domain, and opening the **Health** tab.

<img alt="Domain Health" />

***

## Health statuses

| Status | What it means |
| - | - |
| **Healthy** | Everything looks good, keep sending |
| **Warning** | Getting close to the threshold, review your list |
| **Critical** | Threshold exceeded, take action now |
| **Suspended** | Sending has been paused, contact support |

***

## Health Metrics

### Hard bounce rate

Only hard bounces count: addresses that do not exist or can never receive mail. This is the same measure AWS uses to judge email senders. Soft bounces, such as a full mailbox or a temporary block, do not count.

#### Custom Domains

| Threshold | Status |
| - | - |
| \< 2% | Healthy |
| 2-5% | Warning |
| 5% or more for 24 hours | Critical → Suspension |

#### Managed Domains (stricter)

| Threshold | Status |
| - | - |
| \< 2% | Healthy |
| 2-4% | Warning |
| 4% or more | Critical → Suspension |

**Hard bounce rate formula:**

```text theme={null}
Hard Bounce Rate = (Hard Bounces / Total Sent) × 100
```

### Complaint Rate

#### Custom Domains

| Threshold | Status |
| - | - |
| \< 0.1% | Healthy |
| 0.1-0.5% | Warning |
| > 0.5% | Critical → Suspension |

#### Managed Domains (stricter)

| Threshold | Status |
| - | - |
| \< 0.03% | Healthy |
| 0.03-0.1% | Warning |
| > 0.1% | Critical → Suspension |

**Complaint rate**

| | Healthy | Warning | Suspended |
| - | - | - | - |
| Custom domain | Below 0.1% | 0.1% to 0.5% | Above 0.5% |
| Managed domain | Below 0.03% | 0.03% to 0.1% | Above 0.1% |

<Note>
  Thresholds apply after a minimum volume: **50+ emails** for managed domains, **100+ emails** for custom domains. Small volumes aren't penalized for occasional bounces.
</Note>

<Tip>
  Managed domains have stricter thresholds because they share infrastructure — one sender's poor list quality can affect all managed domain users. For production campaigns with large audiences, we recommend [using your own domain](/sending-domains/add-domain).
</Tip>

***

## Health Dashboard

The health dashboard shows:

| Metric | Description |
| - | - |
| **Status** | Current health status (Healthy/Warning/Critical) |
| **Total Sent** | Lifetime emails sent from this domain |
| **Total Bounced** | Lifetime bounced emails |
| **Total Complaints** | Lifetime spam complaints |
| **Bounce Rate** | Current percentage |
| **Complaint Rate** | Current percentage |
| **Last Updated** | When metrics were last calculated |

***

## What Causes Poor Health?

### High Bounce Rate

Common causes:

* **Old email lists** - Addresses go stale over time
* **Purchased lists** - Often contain invalid addresses
* **Typos** - Users entering wrong email addresses
* **Inactive domains** - Company domains that no longer exist

### High Complaint Rate

Common causes:

* **No permission** - Sending to people who didn't opt in
* **Irrelevant content** - Content doesn't match expectations
* **Too frequent** - Sending too many emails
* **Hard to unsubscribe** - Users mark as spam instead
* **Misleading subject lines** - Content doesn't match promise

***

## How to keep your domain healthy

<AccordionGroup>
  <Accordion title="Clean your list regularly" icon="broom">
    Remove hard bounces immediately. Remove soft bounces after three consecutive failures. Remove anyone who has not opened an email in six months or more. Migma suppresses bounces and complaints automatically but you should audit your full list periodically too.
  </Accordion>

  <Accordion title="Make it easy to unsubscribe" icon="door-open">
    Every email should have a clear one-click unsubscribe link that does not require a login. If people cannot get off your list easily they will mark you as spam instead, which is far worse for your domain health.
  </Accordion>

  <Accordion title="Set expectations upfront" icon="handshake">
    When someone subscribes, tell them what they will receive and how often. Matching expectations reduces complaints significantly. Surprises are the main reason people reach for the spam button.
  </Accordion>

  <Accordion title="Use double opt-in" icon="check-double">
    Ask new subscribers to confirm their email address before adding them to your list. This filters out typos, fake addresses, and people who did not really want to sign up.
  </Accordion>
</AccordionGroup>

***

## Domain Suspension

### When It Happens

A domain is suspended when it exceeds its type's thresholds:

**Custom Domains:**

* Bounce rate exceeds 10%
* Complaint rate exceeds 0.5%

**Managed Domains (stricter):**

* Bounce rate exceeds 4%
* Complaint rate exceeds 0.1%

A domain may also be suspended if manual review identifies abuse.

### What Happens

When suspended:

* All email sending from this domain is blocked
* Existing scheduled emails are paused
* You receive a notification
* Dashboard shows "Suspended" status

### Reinstating a Domain

<Steps>
  <Step title="Identify the Issue">
    Review your metrics to understand what caused the suspension:

    * Check bounce logs for patterns
    * Review complaint sources
    * Identify problematic list segments
  </Step>

  <Step title="Clean Your List">
    Remove all problematic addresses:

    * Export your suppression list
    * Cross-reference with your contact list
    * Remove unengaged subscribers
    * Verify remaining addresses
  </Step>

  <Step title="Contact Support">
    Reach out to Migma support with:

    * Your domain name
    * Steps you've taken to fix the issue
    * Your plan to prevent recurrence
  </Step>

  <Step title="Wait for Review">
    Support will review your account and:

    * Verify the issue is resolved
    * May reinstate with a warning
    * May require additional steps
  </Step>
</Steps>

***

## Monitoring Best Practices

| Frequency | Check |
| - | - |
| **Daily** | Review bounce notifications |
| **Weekly** | Check health dashboard |
| **Monthly** | Clean unengaged subscribers |
| **Quarterly** | Full list audit |

***

## Recovery tips

If your domain is in Warning or Critical status, stop sending campaigns temporarily. Identify which recent send caused the issue, remove anyone who has not engaged in the last three months, and resume sending only to your most active subscribers. Build back up gradually from there.

***

## What do you want to do next?

<CardGroup>
  <Card title="Domain metrics" icon="chart-line" href="/sending-domains/metrics">
    See detailed delivery, open, and complaint data.
  </Card>

  <Card title="Suppression list" icon="ban" href="/sending-domains/suppression-list">
    See which addresses are blocked from receiving your emails.
  </Card>

  <Card title="Domain warming" icon="fire" href="/sending-domains/domain-warming">
    Build reputation gradually on a new domain.
  </Card>

  <Card title="Email logs" icon="list" href="/sending-domains/email-logs">
    Check the status of individual emails.
  </Card>
</CardGroup>


# Domain Settings
Source: https://docs.migma.ai/sending-domains/domain-settings

Each sending domain has configurable settings that control how emails are tracked and delivered. Access these settings at Settings → Sending Domains → [Your Domain].

## Overview

Each sending domain has configurable settings that control how emails are tracked and delivered. Access these settings at **Settings → Sending Domains → \[Your Domain]**.

***

## Tracking Settings

### Open Tracking

| Setting | Default |
| - | - |
| Open Tracking | **Enabled** |

When enabled, Migma inserts a 1x1 transparent pixel image at the end of your email. When a recipient opens the email and loads images, this pixel is requested from Migma's servers, recording the open.

**What's tracked:**

* First open timestamp
* Total open count
* Approximate location (from IP)

**When to disable:**

* Privacy-focused audiences
* Emails where image loading is blocked
* Transactional emails where open rates don't matter

***

### Click Tracking

| Setting | Default |
| - | - |
| Click Tracking | **Enabled** |

When enabled, Migma rewrites links in your email to route through our tracking servers. When a recipient clicks a link, we record the click and redirect them to the original URL.

**What's tracked:**

* First click timestamp
* Total click count per email
* Which links were clicked

**When to disable:**

* When you need original URLs visible in the email
* High-security contexts where redirects are a concern
* When third-party link tracking is already in place

***

### Branded Tracking

| Setting | Default |
| - | - |
| Branded Tracking | **Disabled** |

When enabled, Migma adds a small "Sent with Migma" footer to your emails. This includes a logo that also serves as an open tracking pixel.

**Why enable:**

* Support Migma with visible branding
* Simple alternative to custom open tracking

**Why disable (default):**

* Keep emails unbranded
* Custom footer design

***

## Updating Settings

### In the Dashboard

<Steps>
  <Step title="Navigate to Domain">
    Go to **Settings → Sending Domains** and click on your domain.
  </Step>

  <Step title="Find Tracking Settings">
    Scroll to the **Tracking** section.
  </Step>

  <Step title="Toggle Settings">
    Click the toggle next to each setting to enable or disable.
  </Step>

  <Step title="Save Changes">
    Changes are saved automatically.
  </Step>
</Steps>

### Settings Summary

| Setting | Enabled | Disabled |
| - | - | - |
| **Open Tracking** | 1x1 pixel inserted | No tracking pixel |
| **Click Tracking** | Links rewritten | Original URLs preserved |
| **Branded Tracking** | "Sent with Migma" footer | No footer added |

***

## How Tracking Works

### Open Tracking Flow

```text theme={null}
1. Email sent with tracking pixel
2. Recipient opens email
3. Email client loads images
4. Pixel request hits Migma servers
5. Open recorded with timestamp
```

### Click Tracking Flow

```text theme={null}
1. Links rewritten: example.com → track.migma.ai/c/[id]
2. Recipient clicks link
3. Request hits Migma tracking server
4. Click recorded with timestamp
5. Recipient redirected to original URL
```

***

## Data Retention

Tracking data is stored for **30 days**. After 30 days, individual email logs are automatically deleted. Aggregate metrics (totals per domain) are retained indefinitely.

***

## Best Practices

<AccordionGroup>
  <Accordion title="Enable both for marketing emails" icon="envelope-open-text">
    For newsletters, promotions, and marketing campaigns, keep both open and click tracking enabled. This data helps you:

    * Measure campaign effectiveness
    * Identify engaged subscribers
    * Optimize send times
    * A/B test content
  </Accordion>

  <Accordion title="Consider disabling for transactional emails" icon="receipt">
    For password resets, order confirmations, and receipts, tracking may be unnecessary:

    * Users expect these emails regardless
    * Open rates are typically very high anyway
    * Reduces email size slightly
    * Avoids potential privacy concerns
  </Accordion>

  <Accordion title="Separate domains for different use cases" icon="sitemap">
    If you need different tracking settings, use separate subdomains:

    * `mail.yourdomain.com` - Marketing (tracking enabled)
    * `notify.yourdomain.com` - Transactional (tracking disabled)
  </Accordion>
</AccordionGroup>

***

## Transactional vs Marketing Streams

Mailbox providers score sender reputation per signing domain, so mixing promotional sends with critical mail like password resets and receipts lets one drag down the other. Migma keeps them apart:

| Stream | Address | Recipients | Unsubscribe header |
| - | - | - | - |
| Marketing | `yourdomain.com` | Subscribed contacts only | Added |
| Transactional | `notify.yourdomain.com` | Everyone except hard bounces | Omitted |

Roots set up earlier may still have `send.yourdomain.com`. That address keeps working as a marketing sender. New domains do not create it.

Migma picks the stream automatically: a send to a single recipient is treated as transactional, a send to an audience or tag is treated as marketing. You can override this per send with the `transactional` flag.

### Provisioning a stream

Provision the subdomain once, publish the DNS records it returns, then verify it.

```typescript Node.js SDK theme={null}
await migma.domains.provisionStream({
  rootDomain: 'yourdomain.com',
  stream: 'transactional',
});
```

```bash CLI theme={null}
migma domains streams create yourdomain.com --stream transactional
```

Until a transactional address exists, transactional sends fall back to your main domain or leftover marketing identity. They still deliver, but they share that identity's reputation instead of being isolated.

<Tip>
  Provisioning is also available in the dashboard at **Settings → Sending Domains**. The API and CLI exist so you can set this up without leaving your own tooling.
</Tip>

***

## Next Steps

<CardGroup>
  <Card title="View Metrics" icon="chart-line" href="/sending-domains/metrics">
    See domain performance data
  </Card>

  <Card title="Email Logs" icon="list" href="/sending-domains/email-logs">
    View individual email status
  </Card>
</CardGroup>


# Domain Warming
Source: https://docs.migma.ai/sending-domains/domain-warming

Warm a new Migma sending domain gradually with engaged, permission-based recipients, increasing volume safely while monitoring bounces and complaints.

When you add a brand new domain, email providers like Gmail and Outlook have never seen it before. Sending a large volume of emails right away looks suspicious and can get your emails filtered to spam or your domain blocked.

Domain warming fixes this by starting with a small daily sending limit and increasing it gradually. While warmup is active, Migma enforces the limit across campaigns and API sends, then pauses warmup if bounce or complaint rates cross the safety setting you chose.

<Note>
  Domain warming is for domains you own. A managed Migma address uses shared reputation and a fixed daily limit, so it does not warm. [Add a domain you own](/sending-domains/add-domain) when you need your own reputation and higher limits.
</Note>

***

## How to start warming

Your own domain needs to be verified before you can start. If you have not done that yet, see [Add Sending Domain](/sending-domains/add-domain) first.

1. Go to **Sending Domains** in the left sidebar
2. Click on your domain
3. Find the **Domain Warming** section
4. Review the starting volume, daily growth, and safety setting
5. Click **Start warmup**

<img alt="Start Domain Warming" title="Start Domain Warming" />

The recommended plan starts at 50 emails on day 1, grows by 1.25x on each send day, and pauses above the Balanced safety threshold.

***

## Daily sending limits

Warming follows the settings shown before you start. The default Balanced plan reaches 10,000 daily sends on day 24.

| Send day | Daily limit |
| - | - |
| Day 1 | 50 emails |
| Day 4 | 110 emails |
| Day 8 | 290 emails |
| Day 12 | 750 emails |
| Day 16 | 1,900 emails |
| Day 20 | 5,900 emails |
| Day 24 | 10,000 emails |

Faster growth options are available for domains with sending history and clean lists. Slower settings are safer for new domains.

You can check how many emails you have left for the day at any time by clicking on your domain in **Sending Domains**.

***

## Managing warming

**Pause warming** — if you need to stop temporarily, click **Pause** from the Warming tab. Migma stops applying warmup caps until you resume.

**Resume warming** — click **Resume** to pick up from the same day and limit.

**Check your progress** — your domain page shows the current day, today's limit, emails sent, remaining capacity, next cap, schedule preview, and safety thresholds.

***

## Tips for a smooth warm-up

**Send every day.** Even a small batch of 10 to 20 emails helps. Skipping days slows down reputation building and signals inconsistency to email providers.

**Send to your most engaged subscribers first.** People who open and click regularly give you the best engagement rates during warming, which helps build reputation faster.

**Keep your list clean.** High bounce rates or spam complaints can pause warming automatically. Balanced safety pauses above 3% bounce rate or 0.07% complaint rate after enough volume.

**Let Migma split large sends.** If a campaign is larger than today's safe capacity, Migma sends what it can and waits for more capacity instead of forcing the full list through at once.

***

## Warming statuses

| Status | What it means |
| - | - |
| **Not started** | Click Start Warming to begin |
| **In progress** | Warming is active, keep sending within limits |
| **Paused** | Warmup caps are off, click Resume to continue the ramp |
| **Completed** | Daily cap reached the warmup target |
| **Failed** | Stopped due to reputation risk, review domain health before resuming |

***

## Something not working?

<AccordionGroup>
  <Accordion title="Warming paused automatically" icon="pause">
    This usually means your bounce or complaint rate crossed the safety threshold. Clean your subscriber list, remove invalid addresses, and check your domain health before resuming. Reach out to support if you are not sure what caused it.
  </Accordion>

  <Accordion title="Cannot send emails during warming" icon="ban">
    If warmup is active, check whether you have hit today's daily limit. Limits reset at midnight UTC. A user-paused warmup does not block sends; an automatic safety pause requires review before resuming. If your domain is not yet verified, complete verification before warming can begin.
  </Accordion>

  <Accordion title="Warming feels slow" icon="clock">
    Use a lower starting volume or slower daily growth for new domains. Use faster growth only when the domain already has sending history and your list is clean.
  </Accordion>
</AccordionGroup>

***

## What do you want to do next?

<CardGroup>
  <Card title="Domain health" icon="heart-pulse" href="/sending-domains/domain-health">
    Monitor your bounce and complaint rates.
  </Card>

  <Card title="Domain settings" icon="gear" href="/sending-domains/domain-settings">
    Configure open and click tracking.
  </Card>

  <Card title="Send a campaign" icon="rocket" href="/campaigns/send-campaign">
    Send your first email from your new domain.
  </Card>

  <Card title="Add Sending Domain" icon="globe" href="/sending-domains/add-domain">
    Set up a new sending domain.
  </Card>
</CardGroup>


# Email Logs
Source: https://docs.migma.ai/sending-domains/email-logs

Email logs show the delivery status and tracking data for each email sent from your domain. View logs at Settings → Sending Domains → [Your Domain] → Email Logs.

## Overview

Email logs show the delivery status and tracking data for each email sent from your domain. View logs at **Settings → Sending Domains → \[Your Domain] → Email Logs**.

***

## Log Data

Each email log entry includes:

| Field | Description |
| - | - |
| **Tracking ID** | Unique identifier for the email |
| **From** | Sender email address |
| **To** | Recipient email address |
| **Subject** | Email subject line |
| **Status** | Current delivery status |
| **Sent At** | When the email was sent |
| **Opened At** | First open timestamp (if tracked) |
| **Clicked At** | First click timestamp (if tracked) |
| **Open Count** | Total opens |
| **Click Count** | Total clicks |

***

## Email Status

| Status | Meaning |
| - | - |
| **sent** | Email accepted for delivery |
| **delivered** | Successfully delivered to recipient's server |
| **opened** | Recipient opened the email |
| **clicked** | Recipient clicked a link |
| **bounced** | Delivery failed |
| **complained** | Marked as spam by recipient |

### Status Flow

```text theme={null}
sent → delivered → opened → clicked
            ↓
        bounced
            ↓
       complained
```

An email can have multiple statuses. For example, an email can be:

* `delivered` + `opened` + `clicked`
* `delivered` + `complained`
* `bounced` (never delivered)

***

## Viewing Logs

### List View

The log list shows recent emails with:

* Recipient
* Subject
* Status (with color indicator)
* Sent time
* Open/click counts

### Detail View

Click any email to see full details:

* Complete tracking history
* All timestamps
* Bounce type (if bounced)
* Complaint type (if complained)
* Expiration date

***

## Filtering Logs

Filter emails by:

| Filter | Options |
| - | - |
| **Status** | sent, delivered, opened, clicked, bounced, complained |
| **Date range** | Last 24 hours, 7 days, 30 days, custom |
| **Search** | Recipient email address |

***

## Bounce Details

When an email bounces, additional details are available:

| Field | Description |
| - | - |
| **Bounce Type** | Permanent, Transient, or Undetermined |
| **Bounce Subtype** | Specific reason (e.g., "General", "NoEmail") |
| **Diagnostic** | Technical error message |

### Common Bounce Types

| Type | Subtype | Meaning |
| - | - | - |
| Permanent | General | Address doesn't exist |
| Permanent | NoEmail | Mailbox not found |
| Permanent | Suppressed | On suppression list |
| Transient | MailboxFull | Recipient's inbox is full |
| Transient | MessageTooLarge | Email too large |
| Transient | ContentRejected | Content blocked by filter |

***

## Complaint Details

When a recipient marks your email as spam:

| Field | Description |
| - | - |
| **Complaint Type** | Usually "abuse" |
| **Feedback Type** | Type of complaint |
| **Timestamp** | When complaint was received |

<Note>
  Complaints are automatically added to your suppression list to prevent future sends.
</Note>

***

## Data Retention

Email logs are retained for **30 days**. After 30 days:

* Individual email logs are automatically deleted
* Aggregate metrics remain available
* Suppression list entries remain permanent

***

## Exporting Logs

Export email logs as CSV for analysis:

1. Go to **Email Logs**
2. Apply any filters
3. Click **Export**
4. Download CSV file

Exported data includes all fields visible in the detail view.

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="Email shows 'sent' but not 'delivered'" icon="clock">
    **Possible causes:**

    * Delivery is still in progress (wait a few minutes)
    * Recipient's server is slow to respond
    * Email was soft-bounced and will retry

    **Action:** Check again in 15-30 minutes. If still not delivered, check bounce status.
  </Accordion>

  <Accordion title="Opens not tracking" icon="eye-slash">
    **Possible causes:**

    * Open tracking is disabled for this domain
    * Recipient's email client blocks images
    * Email client uses a privacy proxy (Apple Mail Privacy Protection)

    **Note:** Open tracking is becoming less reliable due to privacy features in modern email clients.
  </Accordion>

  <Accordion title="Clicks not tracking" icon="link-slash">
    **Possible causes:**

    * Click tracking is disabled for this domain
    * Links weren't rewritten (plain text emails)
    * Security software pre-clicked links

    **Note:** Some security tools click all links to scan for malware, which can inflate click counts.
  </Accordion>
</AccordionGroup>

***

## Next Steps

<CardGroup>
  <Card title="Domain Metrics" icon="chart-line" href="/sending-domains/metrics">
    View aggregate statistics
  </Card>

  <Card title="Suppression List" icon="ban" href="/sending-domains/suppression-list">
    Manage blocked addresses
  </Card>
</CardGroup>


# Domain Metrics
Source: https://docs.migma.ai/sending-domains/metrics

Monitor Migma sending-domain delivery, bounce, complaint, open, and click metrics, interpret changes, and decide when a sender needs attention.

Migma tracks performance for every email sent from your domain. You can find your metrics by going to **Sending Domains**, clicking on your domain, and opening the **Metrics** tab.

<img alt="Domain Metrics" title="Domain Metrics" />

***

## What you can see

**Emails sent** — total emails sent from this domain.

**Delivered** — emails that successfully reached the recipient's inbox.

**Opened** — emails that were opened. Only tracked if open tracking is enabled.

**Clicked** — emails where someone clicked at least one link. Only tracked if click tracking is enabled.

**Bounced** — emails that could not be delivered.

**Complained** — emails that a recipient marked as spam.

***

## Healthy ranges to aim for

| Metric | Healthy range |
| - | - |
| Delivery rate | Above 95% |
| Open rate | 15% to 30% |
| Click rate | 2% to 5% |
| Bounce rate | Below 5% |
| Complaint rate | Below 0.1% |

You can view trends over the last 7, 30, or 90 days to spot any changes over time.

***

## Bounces

Not all bounces are the same. Migma breaks them down into three types:

**Permanent** — the email address or domain does not exist. Remove these from your list immediately. Migma adds them to your suppression list automatically so you never send to them again.

**Transient** — a temporary issue like a full mailbox or a server being down. These can be retried.

**Undetermined** — the reason is unclear. Keep an eye on these as they can become permanent over time.

***

## Complaints

When someone marks your email as spam, Migma records it as a complaint, adds that address to your suppression list, and updates your complaint rate.

<Warning>
  A complaint rate above 0.1% can trigger domain suspension. Keep your list clean and make it easy for people to unsubscribe so they do not reach for the spam button instead.
</Warning>

***

## What to watch for

<AccordionGroup>
  <Accordion title="Delivery rate drops suddenly" icon="chart-line">
    A sudden drop usually means list quality issues, bad addresses, or a reputation problem. Check your bounce logs and review any recent list imports if delivery falls below 95%.
  </Accordion>

  <Accordion title="Complaint rate climbing" icon="triangle-exclamation">
    This is the most important metric for deliverability. Below 0.05% is excellent. Between 0.1% and 0.3% is a warning. Above 0.3% is critical and puts your domain at risk. Review your email content and clean your list if complaints spike.
  </Accordion>

  <Accordion title="Open rate declining over time" icon="envelope-open">
    Declining opens can mean your subject lines need work, you are sending too often, or your list is fatigued. It can also mean emails are going to spam. Try different subject lines and check whether delivery rate is still healthy.
  </Accordion>
</AccordionGroup>

***

## Data retention

Individual email logs are kept for 30 days. Daily aggregate metrics are kept for 90 days. Lifetime totals are kept indefinitely.

***

## What do you want to do next?

<CardGroup>
  <Card title="Email logs" icon="list" href="/sending-domains/email-logs">
    See the status of individual emails sent from your domain.
  </Card>

  <Card title="Domain health" icon="heart-pulse" href="/sending-domains/domain-health">
    Monitor your domain health score and what affects it.
  </Card>

  <Card title="Suppression list" icon="ban" href="/sending-domains/suppression-list">
    See which addresses are blocked from receiving your emails.
  </Card>

  <Card title="Domain warming" icon="fire" href="/sending-domains/domain-warming">
    Build your sender reputation gradually on a new domain.
  </Card>
</CardGroup>


# Avoiding MX Record Conflicts
Source: https://docs.migma.ai/sending-domains/mx-record-conflicts

Avoid MX record conflicts when configuring a Migma sending domain, preserving existing inbound mail while setting the correct custom MAIL FROM records.

## What is an MX Record?

MX (Mail Exchanger) records specify where incoming mail should be delivered for a domain. Every MX record has a priority value—the lower the number, the higher the priority.

Migma requires you to set up an MX record on `send.[sending-domain]` to establish a return-path for bounce and complaint reports from inbox providers. If your sending domain is `mail.yourdomain.com`, the MAIL FROM hostname is `send.mail.yourdomain.com`.

***

## Won't This Conflict with My Existing Email Provider?

**No, it won't.** Here's why:

### How MX Records Work

MX records only affect the specific subdomain (or domain) they're associated with. They don't impact other subdomains or the root domain.

### Example: You Use Google Workspace

Say you're using Google Workspace for your email. You'll have MX records that look like this:

```text theme={null}
yourdomain.com     MX    10    alt3.aspmx.l.google.com.
yourdomain.com     MX    20    alt4.aspmx.l.google.com.
```

These records specify that incoming mail to `anything@yourdomain.com` should be delivered to Google's servers.

### Adding Migma's MX Record

When you add a sending domain to Migma, you need to add an MX record for `send.[sending-domain]`:

```text theme={null}
send.yourdomain.com          MX    10    [Migma-provided value]
send.mail.yourdomain.com     MX    10    [Migma-provided value]
```

**This won't conflict** because:

* The Migma MX record is for the `send` hostname under your sending domain
* Your Google MX records are for your inbox domain
* These are separate hostnames

| Emails sent to... | Delivered to... |
| - | - |
| `hello@yourdomain.com` | Google Workspace |
| `support@yourdomain.com` | Google Workspace |
| `anything@send.yourdomain.com` | Migma (for bounce handling) |
| `anything@send.mail.yourdomain.com` | Migma (for bounce handling) |

Your existing email flow is unaffected.

***

## Why Migma Uses the `send` Subdomain

Migma specifically uses the `send` subdomain for the MAIL FROM (return-path) because:

1. **No conflicts** - It doesn't interfere with your existing MX records
2. **Better deliverability** - Bounce handling is properly configured
3. **Separation of concerns** - Sending infrastructure is isolated from receiving

***

## Common MX Record Conflicts

<AccordionGroup>
  <Accordion title="Existing record on `send` subdomain" icon="triangle-exclamation">
    **Problem:** You already have an MX record for `send.[sending-domain]` from another service.

    **Solutions:**

    1. **Remove the existing record** if you no longer use that service

    2. **Use a different subdomain** in Migma (contact support for custom MAIL FROM subdomain configuration)
  </Accordion>

  <Accordion title="Same priority value (10) already in use" icon="list-ol">
    **Problem:** You have another MX record with priority 10 for the same subdomain.

    **Solution:** Each MX record should have a unique priority. Either:

    * Change Migma's priority to a different number (e.g., 5)
    * Update your existing record to a different priority

    <Note>
      If two MX records have the same priority, mail servers will randomly choose one per delivery attempt—they won't deliver to both.
    </Note>
  </Accordion>

  <Accordion title="DNS provider auto-appending domain name" icon="text-slash">
    **Problem:** Your MX record appears as:

    ```text theme={null}
    feedback-smtp.us-east-1.amazonses.com.yourdomain.com
    ```

    Instead of:

    ```text theme={null}
    feedback-smtp.us-east-1.amazonses.com
    ```

    **Solution:** Add a trailing period (dot) at the end of the MX value:

    ```text theme={null}
    feedback-smtp.us-east-1.amazonses.com.
    ```

    The trailing period tells your DNS provider this is a fully qualified domain name that should not be modified.
  </Accordion>
</AccordionGroup>

***

## Checking Your MX Records

### Using a Web Tool

Use [MXToolbox](https://mxtoolbox.com/SuperTool.aspx) or [DNS Checker](https://dnschecker.org) to verify your MX records:

1. Enter `send.[sending-domain]`, such as `send.mail.yourdomain.com`
2. Select "MX Lookup"
3. Verify the record matches what Migma provided

### Using the Terminal

```bash theme={null}
# Check MX record for your MAIL FROM hostname
nslookup -type=MX send.mail.yourdomain.com

# Or using dig
dig MX send.mail.yourdomain.com
```

You should see the value Migma provided with priority 10.

***

## Summary

| Your existing MX records | Migma's MX record | Conflict? |
| - | - | - |
| `yourdomain.com` -> Google | `send.yourdomain.com` -> Migma | No |
| `yourdomain.com` -> Microsoft 365 | `send.mail.yourdomain.com` -> Migma | No |
| `mail.yourdomain.com` -> Your server | `send.mail.yourdomain.com` -> Migma | No |
| `send.mail.yourdomain.com` -> Other service | `send.mail.yourdomain.com` -> Migma | **Yes** (remove old record) |

The only conflict occurs when you already have something on the exact same full MAIL FROM hostname, such as `send.mail.yourdomain.com`.

***

## Next Steps

<CardGroup>
  <Card title="Domain Verification Issues" icon="circle-question" href="/sending-domains/verification-issues">
    Troubleshoot verification problems
  </Card>

  <Card title="Add Sending Domain" icon="globe" href="/sending-domains/add-domain">
    Complete domain setup guide
  </Card>
</CardGroup>


# Set Up Sending Domains in Migma
Source: https://docs.migma.ai/sending-domains/overview

Sending domains control the address your recipients see and the reputation attached to your email. Use a verified domain before production campaigns whenever possible.

Sending domains control the address your recipients see and the reputation attached to your email. Use a verified domain before production campaigns whenever possible.

The workspace **owner** or a **manager on all brands** can add and manage sending domains. A manager on one brand can send from a ready domain, but cannot change account DNS.

Migma supports three setup paths:

* **Use my domain** for a domain you already own. Migma prepares records and opens Entri one-click DNS setup when available.
* **Buy a domain** for a new sender registered from Migma.
* **Start with a Migma address** for a managed `migma.email` sender without DNS setup. Eligible new accounts receive one after email verification; you can also add one from Sending Domains.

## What Migma sets up

* Domain ownership verification
* DKIM signatures
* SPF authorization
* DMARC policy
* Custom MAIL FROM for bounce handling
* Domain health, metrics, and email logs
* Domain warming for domains you own

## Choose the address recipients see

When you connect a domain, Migma verifies two sending identities:

* `yourbrand.com` for campaigns and anything you send by hand
* `notify.yourbrand.com` for transactional email

Receipts and password resets stay on their own address, so a rough campaign cannot take them down.

* Add a From address on the identity you want recipients to see. `hello@yourbrand.com` lives on the main domain. `hello@notify.yourbrand.com` lives on the transactional identity. SES verifies each identity separately, so one does not inherit the other. Publish lists every sendable identity you have a From on.
* Sends from the main domain use your main domain's reputation, for both types of email. The transactional address keeps receipts isolated.
* Unsubscribe handling, suppression, and compliance follow the type of email you send, not the address you pick.

If a domain you connected earlier still has `send.yourbrand.com`, that address keeps working and still appears as a marketing sender. New domains do not create it.

## Common use cases

* Send campaigns from `hello@yourbrand.com`
* Show your bare domain in the inbox with a verified main domain sender
* Buy a new sending domain for a new brand or campaign line
* Start quickly with a managed Migma address for tests or API workflows
* Warm a new domain you own before larger sends

## Best practices

**Use a domain users recognize.** Sender identity affects trust and complaints.

**Prefer the transactional address for receipts.** `notify.yourbrand.com` keeps password resets and order email off your campaign reputation. Choose the main domain sender when inbox recognition matters more.

**Use one-click DNS when available.** Entri and Cloudflare setup reduce copy-paste DNS mistakes.

**Warm new domains you own.** Increase volume gradually before sending to a full list. Migma addresses use a fixed daily limit and do not warm.

**Watch health and logs.** Bounces, complaints, and failed delivery show reputation risk early.

**Watch the account sending limit.** Daily and monthly counts sit on Sending Domains. When the limit is reached, Campaigns still lets you prepare emails. Sending waits until the limit resets, or you increase limits.

## Next

<CardGroup>
  <Card title="Add a Domain" icon="plus" href="/sending-domains/add-domain">
    Connect a domain, buy a domain, or start with a Migma address.
  </Card>

  <Card title="Buy a Domain" icon="credit-card" href="/sending-domains/buy-domain">
    Register a new sending domain from Migma.
  </Card>

  <Card title="Add DNS Records" icon="server" href="/sending-domains/add-dns-records">
    Copy records into your DNS provider.
  </Card>

  <Card title="Domain Warming" icon="fire" href="/sending-domains/domain-warming">
    Increase sending volume gradually on a domain you own.
  </Card>

  <Card title="Domain Health" icon="heart-pulse" href="/sending-domains/domain-health">
    Review DNS, bounce, complaint, and reputation signals.
  </Card>

  <Card title="Sending Metrics" icon="chart-line" href="/sending-domains/metrics">
    Understand delivery, bounce, and complaint trends.
  </Card>
</CardGroup>


# Suppression List
Source: https://docs.migma.ai/sending-domains/suppression-list

Manage Migma's suppression list for bounced, complained, unsubscribed, or manually blocked addresses so campaigns and API sends exclude them.

## Overview

The suppression list contains email addresses that should not receive emails from your account. Migma automatically blocks sending to these addresses to protect your domain reputation.

Open the list at **Contacts → Suppression**. Each address shows the reason it was added — *bounce*, *complaint*, *unsubscribe*, or *manual* — along with the underlying detail (SMTP bounce subtype, complaint type, or soft-bounce streak count) so you can tell *why* an address landed on the list.

<Tip>
  Open **Contacts → Suppression**. Filter by bounce, complaint, unsubscribe, or manual block.
</Tip>

***

## How It Works

When you try to send to a suppressed email:

1. Email is blocked before sending
2. No delivery attempt is made
3. The send is logged as "suppressed"
4. Your sending quota is not affected

This prevents damage to your sender reputation from repeated bounces or complaints.

***

## Suppression Reasons

| Reason | Description | How Added |
| - | - | - |
| **bounce** | Email previously bounced (permanent) | Automatic |
| **complaint** | Recipient marked email as spam | Automatic |
| **unsubscribe** | Recipient unsubscribed | Automatic |
| **manual** | Added by you | Manual |

***

## Automatic Suppression

Migma automatically adds addresses when:

### Permanent Bounces

When an email permanently bounces:

* Invalid email address
* Domain doesn't exist
* Mailbox not found

**Added immediately** after the first permanent bounce.

### Spam Complaints

When a recipient marks your email as spam:

* Through their email client (Gmail, Outlook, etc.)
* Via ISP feedback loop

**Added immediately** upon receiving the complaint.

### Unsubscribes

When a recipient unsubscribes:

* Via unsubscribe link in email
* Through preference center
* Via List-Unsubscribe header

**Added immediately** upon unsubscribe.

***

## Viewing the List

### List View

The suppression list shows:

| Column | Description |
| - | - |
| **Email** | The suppressed email address |
| **Reason** | Why they were suppressed |
| **Source** | How they were added (automatic/manual) |
| **Domain** | Which domain triggered suppression |
| **Date** | When they were suppressed |

### Filtering

Filter the list by:

* **Reason**: bounce, complaint, unsubscribe, manual
* **Date range**: When added
* **Search**: Email address

***

## Managing Suppressions

### Adding Addresses Manually

Add addresses you know shouldn't receive email:

<Steps>
  <Step title="Go to Suppression List">
    Navigate to **Contacts → Suppression**
  </Step>

  <Step title="Click Add">
    Click **Add to Suppression List**
  </Step>

  <Step title="Enter Email">
    Enter the email address to suppress
  </Step>

  <Step title="Save">
    Click **Add** to confirm
  </Step>
</Steps>

### Bulk Import

Import multiple addresses at once:

1. Click **Import**
2. Upload a CSV file with email addresses
3. Review the preview
4. Confirm import

**CSV Format:**

```csv theme={null}
email
user1@example.com
user2@example.com
user3@example.com
```

### Removing Addresses

<Warning>
  Be careful when removing addresses. If they were added due to a bounce or complaint, sending to them again will likely hurt your reputation.
</Warning>

To remove an address:

1. Find the address in the list
2. Click the remove icon
3. Confirm removal

**When it's safe to remove:**

* Manual additions that are no longer needed
* Addresses that were mistakenly added
* Re-engagement campaigns (with explicit permission)

***

## Suppression and Sending

### What Happens When You Send

When sending to a list that includes suppressed addresses:

| Result | Count |
| - | - |
| **Sent** | Emails delivered to non-suppressed addresses |
| **Suppressed** | Emails blocked (suppressed addresses) |

You'll see both counts in your send report.

### Partial Sends

If you send to 1,000 recipients and 50 are suppressed:

* 950 emails are sent
* 50 are suppressed (not sent, not billed)
* Your report shows both numbers

***

## Best Practices

<AccordionGroup>
  <Accordion title="Never remove automatic suppressions" icon="shield">
    Addresses added automatically (bounces, complaints) should stay suppressed:

    * **Bounces** will bounce again, hurting your rate
    * **Complaints** may complain again, worse for reputation
    * **Unsubscribes** requested not to receive email

    Only remove if you have explicit new permission from the person.
  </Accordion>

  <Accordion title="Export before large campaigns" icon="download">
    Before major sends:

    1. Export your suppression list
    2. Cross-reference with your send list
    3. Ensure your list is clean

    This prevents surprises in your send reports.
  </Accordion>

  <Accordion title="Import known bad addresses" icon="upload">
    Proactively suppress:

    * Role addresses (admin@, info@, support@)
    * Known spam traps
    * Previous hard bounces from other systems
    * Competitors' addresses

    This protects your reputation before issues occur.
  </Accordion>
</AccordionGroup>

***

## Exporting the List

Export your suppression list for backup or analysis:

1. Go to **Suppression List**
2. Apply any filters (optional)
3. Click **Export**
4. Download CSV file

**Exported data includes:**

* Email address
* Reason
* Source
* Date added
* Domain (if applicable)

***

## Data Retention

Suppression list entries are **permanent** by default:

* No automatic expiration
* Manual removal required
* Protects against re-adding problematic addresses

***

## Next Steps

<CardGroup>
  <Card title="Skipped Recipients" icon="filter-circle-xmark" href="/campaigns/skipped-recipients">
    See per-campaign which contacts were filtered out and why
  </Card>

  <Card title="Deliverability & Validation" icon="shield-check" href="/audience/deliverability">
    Risky-address filtering and contact re-validation
  </Card>

  <Card title="Domain Health" icon="heart-pulse" href="/sending-domains/domain-health">
    Monitor reputation metrics
  </Card>

  <Card title="Send to Audience" icon="paper-plane" href="/audience/sending-emails">
    Send emails safely
  </Card>
</CardGroup>


# Domain Verification Issues
Source: https://docs.migma.ai/sending-domains/verification-issues

Troubleshoot a Migma sending domain that will not verify by checking DNS propagation, record names and values, duplicate SPF, CNAME proxying, and DMARC.

## Overview

Verifying a domain involves these steps:

1. Add your domain to Migma
2. Copy the DNS records from Migma
3. Add these records to your DNS provider
4. Click Verify in Migma

When completed correctly, your domain typically verifies within 15 minutes. If your domain isn't verifying, this guide will help you troubleshoot.

***

## Quick Checks

Before diving into detailed troubleshooting, verify these basics:

<Steps>
  <Step title="All Records Added">
    Confirm you've added all 8 DNS records:

    * 1 ownership TXT record
    * 3 DKIM CNAME records
    * 1 SPF TXT record on the sending domain
    * 1 DMARC TXT record
    * 1 MAIL FROM MX record
    * 1 MAIL FROM TXT record
  </Step>

  <Step title="Correct Location">
    Records must be added under the sending domain you added to Migma:

    * DKIM: `[token]._domainkey.[sending-domain]`
    * SPF: `[sending-domain]`
    * DMARC: `_dmarc.[sending-domain]`
    * MAIL FROM: `send.[sending-domain]`

    If the sending domain is `mail.yourdomain.com`, the MAIL FROM hostname is `send.mail.yourdomain.com`.
  </Step>

  <Step title="Values Match Exactly">
    Copy and paste values directly from Migma. Don't type them manually.
  </Step>

  <Step title="Wait for Propagation">
    DNS changes take 5-60 minutes typically. DKIM can take up to 72 hours in rare cases.
  </Step>
</Steps>

***

## Common Verification Issues

### DKIM Records Not Verifying

DKIM verification can take the longest. Here's what to check:

<AccordionGroup>
  <Accordion title="CNAME values have extra characters" icon="text-slash">
    **Problem:** Extra spaces, quotes, or trailing dots in the CNAME value.

    **How to check:**

    ```bash theme={null}
    dig CNAME [token]._domainkey.yourdomain.com
    ```

    **Solution:**

    * Delete the record
    * Copy the value directly from Migma
    * Paste without any modifications
    * Save the record
  </Accordion>

  <Accordion title="CNAME added as TXT record" icon="file-code">
    **Problem:** You accidentally created a TXT record instead of CNAME.

    **Solution:**

    * Delete the incorrect TXT record
    * Create a new CNAME record with the correct type
  </Accordion>

  <Accordion title="Proxy enabled (Cloudflare)" icon="cloud">
    **Problem:** Cloudflare proxy is enabled (orange cloud) for CNAME records.

    **Solution:**

    * Go to Cloudflare DNS settings
    * Find your DKIM CNAME records
    * Click the orange cloud to turn it gray (DNS only)

    Email authentication records cannot be proxied.
  </Accordion>

  <Accordion title="Still pending after 48 hours" icon="clock">
    **Problem:** DKIM verification hasn't completed after 48 hours.

    **Steps:**

    1. Verify the CNAME records are publicly visible:
       ```bash theme={null}
       dig CNAME [token]._domainkey.yourdomain.com
       ```
    2. If records aren't visible, check with your DNS provider
    3. Delete and re-add the domain in Migma
    4. Add fresh DNS records
  </Accordion>
</AccordionGroup>

### SPF Record Not Verifying

<AccordionGroup>
  <Accordion title="Multiple SPF records exist" icon="copy">
    **Problem:** You have more than one TXT record starting with `v=spf1`.

    **How to check:**

    ```bash theme={null}
    dig TXT yourdomain.com | grep spf
    ```

    If you see multiple `v=spf1` records, you have duplicates.

    **Solution:**

    * Keep only ONE SPF record
    * Combine all includes into a single record:
      ```text theme={null}
      v=spf1 include:_spf.google.com include:spf.migma.ai ~all
      ```
  </Accordion>

  <Accordion title="Include not added correctly" icon="code">
    **Problem:** `include:spf.migma.ai` is in the wrong position or has typos.

    **Correct format:**

    ```text theme={null}
    v=spf1 include:spf.migma.ai ~all
    ```

    **With existing includes:**

    ```text theme={null}
    v=spf1 include:_spf.google.com include:spf.migma.ai ~all
    ```

    **Common mistakes:**

    * `v=spf1 ~all include:spf.migma.ai` (include must be before \~all)
    * `v=spf1 include:spf.migma.ai` (missing \~all or -all at end)
    * `v=spf1 include: spf.migma.ai ~all` (extra space)
  </Accordion>

  <Accordion title="SPF added to wrong domain" icon="sitemap">
    **Problem:** SPF record added to a different domain than the sending domain.

    **Check:** SPF for sending authorization should be on the exact sending domain you added in Migma. If you added `mail.yourdomain.com`, the SPF record belongs on `mail.yourdomain.com`, not `yourdomain.com`.

    **Note:** You also need a separate SPF record on `send.[sending-domain]` for MAIL FROM.
  </Accordion>
</AccordionGroup>

### MAIL FROM Not Verifying

<AccordionGroup>
  <Accordion title="MX record missing or incorrect" icon="envelope">
    **Problem:** The MX record for `send.[sending-domain]` is missing or has wrong value.

    **How to check:**

    ```bash theme={null}
    dig MX send.mail.yourdomain.com
    ```

    **Solution:**

    * Add the MX record with priority 10
    * Copy the value exactly from Migma
    * Ensure the subdomain is `send`, not `mail`
  </Accordion>

  <Accordion title="TXT record for send subdomain missing" icon="file-lines">
    **Problem:** The SPF TXT record for `send.[sending-domain]` is missing.

    **How to check:**

    ```bash theme={null}
    dig TXT send.mail.yourdomain.com
    ```

    **Solution:** Add a TXT record:

    * Name: copy the MAIL FROM name from Migma, often `send` under the sending domain
    * Value: `v=spf1 include:spf.migma.ai ~all`
  </Accordion>

  <Accordion title="MX priority conflict" icon="list-ol">
    **Problem:** Another service already uses priority 10 on `send.[sending-domain]`.

    **Solution:** Use a different priority number (e.g., 5 or 20).

    See [MX Record Conflicts](/sending-domains/mx-record-conflicts) for details.
  </Accordion>
</AccordionGroup>

### DMARC Not Verifying

<AccordionGroup>
  <Accordion title="Record name is wrong" icon="at">
    **Problem:** DMARC record created with incorrect name.

    **Correct:** `_dmarc.yourdomain.com`

    **Common mistakes:**

    * `dmarc.yourdomain.com` (missing underscore)
    * `_dmarc` without domain (depends on DNS provider)

    **Solution:** Create a TXT record with name `_dmarc` (some providers append the domain automatically).
  </Accordion>

  <Accordion title="Invalid DMARC syntax" icon="code">
    **Problem:** DMARC value has syntax errors.

    **Correct format:**

    ```text theme={null}
    v=DMARC1; p=quarantine; rua=mailto:dmarc@migma.ai
    ```

    **Common mistakes:**

    * Extra spaces or missing semicolons
    * Wrong policy value (should be `quarantine` or `reject`)
    * Typo in `DMARC1`
  </Accordion>
</AccordionGroup>

***

## DNS Provider Issues

### Auto-Appending Domain Names

Some DNS providers automatically append your domain to record values.

**Problem:** Your MX record becomes:

```text theme={null}
feedback-smtp.us-east-1.amazonses.com.yourdomain.com
```

Instead of:

```text theme={null}
feedback-smtp.us-east-1.amazonses.com
```

**Solution:** Add a trailing period (dot) at the end:

```text theme={null}
feedback-smtp.us-east-1.amazonses.com.
```

### Records in Wrong DNS Provider

If your domain uses multiple DNS services (registrar, Cloudflare, Vercel, etc.), you might be adding records to the wrong one.

**How to check:**

```bash theme={null}
dig NS yourdomain.com
```

This shows which nameservers control your domain. Add Migma's DNS records at that provider.

***

## Checking Your DNS Records

### Using Web Tools

* [DNS Checker](https://dnschecker.org) - Check propagation globally
* [MXToolbox](https://mxtoolbox.com/SuperTool.aspx) - Detailed DNS lookups
* [DKIM Validator](https://dmarcian.com/dkim-inspector/) - Verify DKIM specifically

### Using Terminal Commands

**Check DKIM CNAME records:**

```bash theme={null}
dig CNAME [token]._domainkey.[sending-domain]
```

**Check SPF record:**

```bash theme={null}
dig TXT [sending-domain] | grep spf
```

**Check DMARC record:**

```bash theme={null}
dig TXT _dmarc.[sending-domain]
```

**Check MAIL FROM MX:**

```bash theme={null}
dig MX send.[sending-domain]
```

**Check MAIL FROM SPF:**

```bash theme={null}
dig TXT send.[sending-domain]
```

***

## DNS Propagation Times

| Record Type | Typical Time | Maximum Time |
| - | - | - |
| TXT (SPF, DMARC) | 5-15 minutes | 24 hours |
| CNAME (DKIM) | 15-60 minutes | 72 hours |
| MX (MAIL FROM) | 5-15 minutes | 24 hours |

If records aren't visible after the maximum time, the issue is with your DNS configuration, not propagation.

***

## Still Not Working?

If you've tried everything above and your domain still won't verify:

<Steps>
  <Step title="Delete and Re-add">
    In Migma, delete the domain and add it fresh. This generates new DNS records.
  </Step>

  <Step title="Screenshot Your DNS">
    Take screenshots of all DNS records you've added.
  </Step>

  <Step title="Contact Support">
    Reach out with:

    * Your domain name
    * Screenshots of your DNS configuration
    * Output from the `dig` commands above
  </Step>
</Steps>

***

## Next Steps

<CardGroup>
  <Card title="MX Record Conflicts" icon="arrows-split-up-and-left" href="/sending-domains/mx-record-conflicts">
    Understand MX record conflicts
  </Card>

  <Card title="Cloudflare Setup" icon="cloud" href="/sending-domains/cloudflare">
    One-click DNS with Cloudflare
  </Card>
</CardGroup>


# Migma Account and Workspace Settings
Source: https://docs.migma.ai/settings/overview

Settings collects account, workspace, sending, integration, and security controls. What you can see depends on your role in the active workspace.

Settings collects account, workspace, sending, integration, and security controls. What you can see depends on your role in the active workspace.

***

## Common settings

| Area | Use it for | Related docs |
| - | - | - |
| Billing | Plan, trial, invoices, payment method, seats | [Plans & Billing](/get-started/billing-and-plans) |
| People | Invite people, set roles, grant all-brand or selected-brand access | [Team access](/collaboration/team-access) |
| Sending Domains | Add domains, DNS, tracking, domain health, logs | [Sending Domains](/sending-domains/overview) |
| Email → Deliverability | Exclude risky addresses and view validation status | [Audience Hygiene](/audience/deliverability) |
| Integrations | Connect ESPs, ecommerce, MCP, and marketing platforms | [Integrations](/integrations/overview) |
| API Integration | Create API keys, webhooks, and agent access | [Agent Guide](/api-reference/introduction) |
| Security | 2FA, account protection, compliance controls | [Security & Compliance](/security/compliance) |

***

## Role access

In **Integrations**, **Sending providers** connects Migma, Amazon SES, Resend, SendGrid, or Mailgun for sends managed by Migma. **Marketing platforms** opens brand connections for Mailchimp, Klaviyo, HubSpot, Omnisend, and Brevo. Choose a brand before connecting a marketing platform.

* Owners manage billing, seats, workspace settings, and all brands.
* Admins can manage people and most workspace controls.
* Members only see settings needed for their role and assigned brands.
* Viewers and commenters do not manage billing or sending setup.
* Viewers and commenters retain read access to connected platform lists and templates for brands they can access. Creating, changing, exporting, or sending provider content requires campaign write access.

See [Seats](/collaboration/seats) and [Team Access](/collaboration/team-access) for role details.

***

## Fast paths

<CardGroup>
  <Card title="Billing" icon="credit-card" href="/get-started/billing-and-plans">
    Plans, trial, invoices, seats, and workspace billing.
  </Card>

  <Card title="People" icon="users-viewfinder" href="/collaboration/team-access">
    Invite teammates and choose brand access.
  </Card>

  <Card title="Sending Domains" icon="globe" href="/sending-domains/overview">
    Verify domains and inspect delivery settings.
  </Card>

  <Card title="Integrations" icon="plug" href="/integrations/overview">
    Connect sending providers and ecommerce tools.
  </Card>

  <Card title="API keys" icon="code" href="/authentication">
    Authenticate API, SDK, CLI, MCP, and agent workflows.
  </Card>

  <Card title="Security" icon="shield-check" href="/security/compliance">
    Review security and compliance controls.
  </Card>
</CardGroup>


# Set Up Migma with an AI Agent
Source: https://docs.migma.ai/setup

Use Migma's agent-guided setup to audit an application's email triggers, reuse or create email drafts, store resource IDs, and wire safe backend sends.

Use `/setup` when you want an AI coding agent to add Migma to an existing app.

It is agent-guided. The agent still reviews and edits your codebase, then uses Migma to create or reuse emails and wire safe server-side sends.

In Migma, the main entry is **Create → Set up Migma with agent**. That dialog copies the `/setup` handoff prompt with skill/plugin install paths, sender/domain status, agent auth guidance, and backend wiring steps.

<Info>
  **For agents:** Fetch the complete documentation index at `https://docs.migma.ai/llms.txt` to discover all available pages before exploring further.
</Info>

To install Migma tooling in your agent first (skills, CLI, MCP), paste one line from [Agent Setup](/agent-setup):

```text theme={null}
Fetch and execute the appropriate instructions to set me up for Migma from https://docs.migma.ai/agent-setup.md
```

## Use it from Migma

<Steps>
  <Step title="Open Create">
    Click **Set up Migma with agent** next to the composer send button.
  </Step>

  <Step title="Copy for AI">
    Migma prepares a prompt for Claude Code, Codex, Cursor, or any skills-compatible agent.
  </Step>

  <Step title="Paste into your agent">
    The prompt asks the agent to install the setup skill or plugin only after you approve it.
  </Step>

  <Step title="Approve access">
    The agent connects hosted MCP, runs `migma login`, or uses [agent registration](/agent-registration). Do not paste a Settings key unless this is CI.
  </Step>
</Steps>

Use [Agent Handoff](/agents/agent-handoff) for the full Create, Publish, API setup, and canvas handoff map.

## Add Migma to your agent

Use the plugin when your agent supports it. It installs the `setup`, `migma`, and `migma-public-api` skills together.

### Claude Code

Install the plugin:

```bash theme={null}
claude plugin marketplace add MigmaAI/migma-skills
claude plugin install migma@migma-plugins
```

Or install only the setup skill:

```bash theme={null}
npx skills add MigmaAI/migma-skills --skill setup -a claude-code
```

To install across all supported agents on this machine:

```bash theme={null}
npx skills add MigmaAI/migma-skills -g
```

### Codex

Install the plugin from the terminal:

```bash theme={null}
codex plugin marketplace add MigmaAI/migma-skills
codex plugin add migma@migma-plugins
```

You can also open `/plugins` in Codex, search for Migma, and install it from the plugin list after adding the marketplace.

### Cursor

Open **Cursor → Settings → Plugins**, paste `https://github.com/MigmaAI/migma-skills`, then install Migma.

Or install only the setup skill:

```bash theme={null}
npx skills add MigmaAI/migma-skills --skill setup -a cursor
```

### Other agents

If your agent supports skills, install the setup workflow:

```bash theme={null}
npx skills add MigmaAI/migma-skills --skill setup
```

If it supports MCP but not skills, connect [MCP](/mcp-server). MCP gives the agent Migma tools, but the `setup` skill is still the better path for codebase audit and backend wiring instructions.

### Terminal install

Use this when you want the CLI and all skills together:

```bash theme={null}
curl -fsSL https://install.migma.ai/setup | sh
```

Or install each part:

```bash theme={null}
curl -fsSL https://install.migma.ai/cli | sh
curl -fsSL https://install.migma.ai/skills | sh
```

## What setup does

1. Audits existing email providers, templates, receipts, invites, campaigns, lifecycle jobs, queues, and webhooks.
2. Resolves the correct Migma brand/project.
3. Lists existing Migma emails and reuses matches.
4. Creates missing emails with prompts grounded in trigger files, recipients, variables, subject copy, and CTAs.
5. Stores each returned `emailId`, subject, sender, and matching app trigger in server-side config or constants.
6. Wires sends only in trusted backend paths.
7. Adds a dry-run or smoke test that verifies each trigger selects the right `emailId` without sending duplicates.

## API access

Use a Migma API key server-side:

```env theme={null}
MIGMA_API_KEY=<set outside chat>
MIGMA_FROM=hello@brand.migma.email
MIGMA_FROM_NAME=Brand
```

Get the key with `migma login` or [agent registration](/agent-registration) at `https://api.migma.ai/auth.md`. Set `MIGMA_API_KEY` for CI. Do not send the agent to Settings to copy a key.

## REST fallback

If plugin or skill install is unavailable, use REST.

| Task | Endpoint |
| - | - |
| List brands/projects | `GET /v1/projects` |
| List existing emails | `GET /v1/projects/emails?projectId=<projectId>` |
| Create emails | `POST /v1/projects/emails/generate` |
| Convert existing HTML | `POST /v1/projects/emails/import-html` |
| Poll generation | `GET /v1/projects/emails/{conversationId}/status` |
| Fetch one email | `GET /v1/emails/{emailId}` |
| Send | `POST /v1/sending` |

Base URL: `https://api.migma.ai`

Auth header: `Authorization: Bearer $MIGMA_API_KEY`

## Guardrails

* Keep API keys and send calls server-side.
* Do not put Migma secrets in browser code.
* Ask before installing packages, calling Migma APIs, creating emails, or sending tests.
* Test before live sends.
* Add idempotency before transactional sends.
* Do not send cold email or email unsubscribed contacts.
* If the app is frontend-only, stop after audit/email creation and add a backend prerequisite before wiring sends.

## Which tool to use

| Surface | Use it for |
| - | - |
| `setup` skill | App audit, email mapping, backend send wiring |
| Migma plugin | Packaging `setup`, `migma`, and public API guidance for agents |
| CLI | Terminal workflows: generate, fetch, edit, send-test, send, campaign, export |
| MCP | Migma-side actions from MCP clients: list, generate, fetch, edit, send, campaign |
| REST or SDK | Production app integration |

Related docs: [Agent Handoff](/agents/agent-handoff), [Skills](/skills), [CLI](/cli), [MCP](/mcp-server), [Authentication](/authentication), [Agent registration](/agent-registration).


# Migma Skills for AI Agents
Source: https://docs.migma.ai/skills

Install Migma skills for AI coding assistants so agents can create, update, test, send, and schedule email work using documented, reviewable workflows.

Migma skills let AI coding assistants create, update, test, send, and schedule emails with Migma. They can also set up Migma inside an existing app by auditing current email triggers, creating the missing Migma emails, and wiring safe backend sends. For OpenClaw, see the dedicated [OpenClaw page](/openclaw).

For the short app-wiring guide, see [/setup](/setup).

<CardGroup>
  <Card title="Guided agent install" icon="download">
    Install paths for supported editors and agents
  </Card>

  <Card title="Natural language" icon="message">
    Ask your agent to handle transactional emails and campaigns
  </Card>

  <Card title="Full API access" icon="code">
    Create, edit, send, campaign, and manage contacts
  </Card>
</CardGroup>

***

## Installation

Use the `skills` CLI when it is available for your agent:

```bash Install script theme={null}
curl -fsSL https://install.migma.ai/skills | sh
```

```bash theme={null}
npx skills add MigmaAI/migma-skills
```

This works with Claude Code, Cursor, Codex, OpenCode, and [35+ other agents](https://github.com/vercel-labs/skills#supported-agents).

### Install to a specific agent

```bash theme={null}
npx skills add MigmaAI/migma-skills -a claude-code
npx skills add MigmaAI/migma-skills -a cursor
npx skills add MigmaAI/migma-skills -a codex
```

### Install one workflow

```bash theme={null}
npx skills add MigmaAI/migma-skills --skill migma
npx skills add MigmaAI/migma-skills --skill setup
```

### Install globally (all projects)

```bash theme={null}
npx skills add MigmaAI/migma-skills -g
```

### Install as a plugin

Add the marketplace once, then install the Migma plugin in your agent.

<CardGroup>
  <Card title="Claude Code" icon="https://mintcdn.com/migmaai/QHH_kDlhE97DvfUZ/images/logos/claude-color.svg?fit=max&auto=format&n=QHH_kDlhE97DvfUZ&q=85&s=87dfd67137723cac140274a92b596a9c">
    ```bash theme={null}
    claude plugin marketplace add MigmaAI/migma-skills
    claude plugin install migma@migma-plugins
    ```
  </Card>

  <Card title="Codex" icon="https://mintcdn.com/migmaai/QHH_kDlhE97DvfUZ/images/logos/openai.svg?fit=max&auto=format&n=QHH_kDlhE97DvfUZ&q=85&s=acbaf5092a31aafd865b5c726ce593ff">
    ```bash theme={null}
    codex plugin marketplace add MigmaAI/migma-skills
    codex plugin add migma@migma-plugins
    ```
  </Card>

  <Card title="Cursor" icon="https://mintcdn.com/migmaai/QHH_kDlhE97DvfUZ/images/logos/cursor.svg?fit=max&auto=format&n=QHH_kDlhE97DvfUZ&q=85&s=b3faa266343083f847bbdf001ce1c506">
    Open Settings, go to Plugins, paste `https://github.com/MigmaAI/migma-skills`, then install Migma.
  </Card>
</CardGroup>

<Tip>
  Browse the [skill source on GitHub](https://github.com/MigmaAI/migma-skills/tree/main/skills/migma) or install it with `npx skills add MigmaAI/migma-skills --skill migma`.
</Tip>

***

## Configuration

### API key

After `migma login`, the CLI stores a key. Local MCP reads that file, or you can set:

```bash theme={null}
export MIGMA_API_KEY=your_migma_api_key
```

CI and servers use `MIGMA_API_KEY`. Do not send agents to Settings to copy a key.

<Tip>
  No key yet? Connect `https://migma.ai/mcp`, run `migma login`, or fetch `https://api.migma.ai/auth.md` and approve a one-time code. See [Agent registration](/agent-registration).
</Tip>

### Default project

Optionally set a default project ID so you don't have to specify it every time:

```bash theme={null}
export MIGMA_PROJECT_ID=proj_abc123
```

***

## Features

| Skill | What the agent can do |
| - | - |
| `setup` | Audit an existing app's email triggers, create or reuse Migma emails, store `emailId` values, wire safe server-side sends |
| `migma` | Generate, edit, test, send, schedule, validate, export, and manage contacts in Migma |

Capabilities covered by the `migma` skill:

Fetch generated emails by `emailId` to retrieve HTML, subject, preheader, screenshot URLs, and email IDs for single emails or series.

| Capability | CLI command used |
| - | - |
| Generate one email | `migma generate "..." --wait --json` |
| Generate a series | `migma generate "..." --count 3 --wait --json` |
| Convert existing HTML | `migma emails import-html ./welcome.html --wait --json` |
| Get generated email HTML | `migma emails get <emailId> --output ./email.html --json` |
| Prompt-edit an email | `migma emails edit <emailId> --prompt "..." --output ./email.html --json` |
| Send a test | `migma send-test --email <emailId> --to test@example.com --json` |
| Send selected email | `migma send --email <emailId> --to user@example.com --subject "Welcome" --from hello@brand.migma.email --from-name "Brand" --json` |
| Send marketing campaign | `migma campaigns create --name "Launch" --conversation <conversationId> --email <emailId> --from hello@brand.migma.email --from-name "Brand" --recipient-type tag --recipient-id <tagId> --json` |

***

## Example usage

Once installed, ask your AI agent things like:

* "Generate a welcome email for new subscribers"
* "Create a three-email onboarding series and show each email ID"
* "Make the welcome email shorter and more transactional"
* "Send that email to [sarah@example.com](mailto:sarah@example.com)"
* "Generate a product launch email and send it to the Newsletter segment"
* "Validate the email for compatibility issues"
* "Import my brand from [https://yourbrand.com](https://yourbrand.com)"
* "Create a managed sending domain called mycompany"
* "List all my contacts tagged VIP"
* "Check the spam score of my email"
* "Export my email for Klaviyo"

***

## Resources

<CardGroup>
  <Card title="OpenClaw" icon="lobster" href="/openclaw">
    Use Migma from WhatsApp, Telegram, Discord
  </Card>

  <Card title="MCP" icon="server" href="/mcp-server">
    Connect Cursor, Codex, Claude, and other agents to Migma
  </Card>

  <Card title="CLI" icon="terminal" href="/cli">
    Migma CLI reference
  </Card>

  <Card title="SDK" icon="code" href="/sdk">
    Node.js SDK
  </Card>

  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Full endpoint docs
  </Card>

  <Card title="Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Get help from the community
  </Card>
</CardGroup>


# Competitor Email Tracking
Source: https://docs.migma.ai/tutorials/competitor-tracking-spy-engine

Every brand you admire has an email strategy. The layouts they use, the offers they lead with, the CTAs they write, all of it is the result of testing and iteration.

Every brand you admire has an email strategy. The layouts they use, the offers they lead with, the CTAs they write, all of it is the result of testing and iteration. And every time they send an email, they are handing you a blueprint.

Migma's competitor tracking collects those emails automatically and lets you turn them into your own campaigns in seconds.

***

## Step 1: Add a competitor to track

1. Go to **Templates** in the left sidebar
2. Click on **Competitors**
3. Click on **Add Website** and paste a URL

<img alt="Competitor Tracking Home" />

Migma subscribes to their list and starts collecting emails as they come in. Every email they send shows up in your **Competitors** tab automatically. You do not have to do anything else.

<Tip>
  Start with two or three brands you respect in your space. You can add more anytime.
</Tip>

***

## Step 2: Browse what they are sending

Go to **Templates** and open the **Competitors** tab. Every email collected from the brands you are tracking shows up here, sorted by most recent first.

<img alt="Competitor Tracking" />

Hover over any card and click on it to see a detailed view of .

This is where patterns start to emerge. How often they send, what subject lines they lean on, whether they go long or short, what their CTAs actually say.

***

## Step 3: Use their best emails into your own

<img alt="Use Competitor Email" title="Use Competitor Email" />

Now just write a prompt describing what you want. Migma takes the structure and layout from the competitor email and rebuilds it with your brand colors, fonts, and copy.

A few prompts to get you started:

> "Use this layout but make it a welcome email for new subscribers. Warm and friendly tone. Button to book a demo at the bottom."

> "Remix this promotion but for our summer sale. 25% off sitewide, ends Friday. Keep the urgency but make it feel more premium."

> "Take this newsletter layout and turn it into our monthly product update. Three new features, one customer story, upcoming webinar on the 20th."

<Tip>
  You keep the layout that someone else has already proven works. Everything else, the brand, the voice, the offer, is yours.
</Tip>

***

## What do you want to do next?

<CardGroup>
  <Card icon="shuffle" href="/creating-emails/remix-emails" title="Remix Emails">
    Learn more about how remixing works.
  </Card>

  <Card icon="message" href="/creating-emails/prompt-based-creation" title="Prompt-Based Creation">
    Write better prompts to get better emails.
  </Card>

  <Card icon="rocket" href="/campaigns/send-campaign" title="Send a Campaign">
    Send your remixed email to your audience.
  </Card>

  <Card icon="chart-bar" href="/campaigns/track-results" title="Track Results">
    See how your campaign performs after sending.
  </Card>
</CardGroup>


# Use Migma with ChatGPT
Source: https://docs.migma.ai/tutorials/connect-migma-to-chatgpt

Connect Migma to ChatGPT with the public plugin or a managed custom connector, approve access, then prepare emails, audiences, campaigns, and reports.

<Frame>
  <img alt="Illustration showing Migma connected to ChatGPT and ready to design emails" />
</Frame>

Connect Migma once, then ask ChatGPT to prepare on-brand emails, inspect campaigns, manage opted-in contacts, and open work in Migma. Browser OAuth handles access, so you do not paste an API key into ChatGPT.

<Info>
  OpenAI moved app discovery into the Plugin Directory. Use the public Migma plugin for the normal setup path. Custom MCP remains available as a fallback for workspaces that manage their own connector.
</Info>

## Start email marketing with ChatGPT

Copy this prompt into ChatGPT:

```text theme={null}
Set up Migma so you can run my email marketing.
Read https://docs.migma.ai/tutorials/connect-migma-to-chatgpt and connect with full access. I'll approve in my browser.
Then show me my brands and suggest what we should do first.
```

## Before you start

You need:

* A Migma account.
* ChatGPT web or desktop access to the Plugin Directory.
* Permission to install and use plugins in your workspace.
* A browser for Migma approval.

Plugin availability depends on your ChatGPT plan, workspace settings, role, supported surface, and region. A workspace admin may need to enable Migma first.

## Connect Migma

<Steps>
  <Step title="Open the Plugin Directory">
    In ChatGPT web or desktop, open **Plugins** from the sidebar. You can also open **Settings → Plugins**.

    Search for **Migma** and select the black Migma envelope logo.

    <Frame>
      <img alt="Illustration showing the ChatGPT Plugin Directory with the correct black Migma envelope logo" />
    </Frame>
  </Step>

  <Step title="Open Migma">
    Review the Migma listing. Select **Connect** when ChatGPT shows it. If Migma is already installed, select **Try now** to start a conversation.

    <Frame>
      <img alt="Illustration showing the Migma plugin listing and Try now button in ChatGPT" />
    </Frame>
  </Step>

  <Step title="Approve Migma access">
    When ChatGPT first needs Migma, follow the browser sign-in flow. Sign in to Migma if needed, then review the app name, return host, and every requested permission.

    `email:send` allows test and live sends. `campaign:write` can create, schedule, or send campaigns. Approve only when you trust this ChatGPT session to act for you.

    <Frame>
      <img alt="Illustration showing ChatGPT requesting Migma access and the Approve connection button" />
    </Frame>

    Migma creates the scoped connection key automatically. No key needs to be copied into ChatGPT.
  </Step>

  <Step title="See your account">
    Invoke Migma with an `@Migma` mention. You can also click **+**, choose **More**, then select Migma.

    Start with:

    ```text theme={null}
    @Migma Show my Migma context and suggest what we should do first.
    ```

    ChatGPT should use Migma and return the brands you can access without changing account data.

    <Frame>
      <img alt="Illustration showing Migma selected in ChatGPT returning account context with brands and suggestions" />
    </Frame>
  </Step>
</Steps>

## Why ChatGPT alone is not enough

A ChatGPT draft is not a campaign:

* Brand fonts, colors, logos, and knowledge need to persist across sends.
* Browser HTML is not email-safe HTML. Outlook, Gmail, and Apple Mail render differently.
* Marketing sends need opted-in contacts, a verified sender, unsubscribes, and your approval.
* Results live in campaign stats, not in a chat thread.

Migma owns those steps. ChatGPT stays the place where you plan and ask.

## Run the marketing workflow

<Steps>
  <Step title="Pick a brand">
    Ask ChatGPT to list brands and choose one. Every later action needs that brand. If ChatGPT asks for a project ID, use the selected brand's project ID.
  </Step>

  <Step title="Save lasting brand facts">
    When you share tone, products, offers, policies, or FAQ that should stick, ask Migma to save them to the knowledge base. Those facts improve later emails.
  </Step>

  <Step title="Design emails and show drafts first">
    Ask for one email or a short series. ChatGPT should wait until the drafts are ready, then show preview images and each canvas link. Review the drafts before requesting compatibility, deliverability, or spam checks.
  </Step>

  <Step title="Import or build the audience">
    Upload or paste an opted-in contact CSV and name the list. Ask Migma to import the full CSV in one step. You can also create a segment from existing contacts.
  </Step>

  <Step title="Confirm the sender">
    Campaigns need a sending domain and From address. Ask Migma to list available domains. If none are ready, set up a domain you own or start with a managed Migma address.
  </Step>

  <Step title="Check, then prepare the campaign">
    After you approve the draft, ask for a test send, inbox checks, or a small edit. Then create a campaign draft with the subject, sender, and recipient list or segment. Ask ChatGPT to wait for your approval before any live send or schedule.
  </Step>

  <Step title="Read results">
    After sending, ask for campaign stats and delivery logs. Use clicks, bounces, and complaints to improve the next brief.
  </Step>
</Steps>

<Frame>
  <img alt="Illustration of four coordinated emails ready for review on the Migma canvas" />
</Frame>

## Prompts worth saving

### Design one email

```text theme={null}
@Migma Use brand [name].
Create one editable marketing email.
Audience: [who]
Goal: [what they should do]
Facts only: [approved claims and URLs]
One primary CTA. Do not invent metrics.
Show the preview image and canvas link when ready.
Do not validate or send yet.
```

### Design a series

```text theme={null}
@Migma Use brand [name].
Prepare a three-email onboarding series.
Email 1: first value
Email 2: remove setup friction
Email 3: invite the next action
Keep them as editable drafts and show each preview when ready.
```

### Import a CSV list

```text theme={null}
@Migma Use brand [name].
Import this CSV into a list named "[list name]".
These contacts opted in on our site.
Use one contact import with the full CSV text.
Report created, updated, skipped, and failed counts.
Do not convert the CSV to JSON contacts.
```

### Prepare a campaign for approval

```text theme={null}
@Migma Use brand [name].
Create a campaign draft from email [email id or canvas link].
Recipients: list or segment [name]
Subject: [subject]
Sender: [from name / domain if known]
Keep it in draft. Show recipient count, subject, and sender, then wait for my approval.
```

After you approve:

```text theme={null}
Send the campaign now.
Or: schedule it for [date] [time] [timezone].
Confirm when it starts, then show stats when available.
```

### Read performance

```text theme={null}
@Migma Show stats and recent delivery logs for campaign [name or id].
Highlight opens, clicks, bounces, and complaints in plain language.
```

## What ChatGPT should and should not do

| Do | Do not |
| - | - |
| Start by listing brands or designing | Paste API keys into chat |
| Show previews before checks or edits | Run preflight before the first reveal |
| Import an opted-in CSV in one step | Convert CSV rows to JSON bulk import |
| Ask before live send or schedule | Guess the audience, sender, or send time |
| Save lasting facts to the knowledge base | Invent product claims or metrics |

## Sending rules

* Send only to contacts with marketing consent. See [What you can send](/get-started/what-you-can-send).
* Use a verified sending domain before live campaigns. See [Sending domains](/sending-domains/overview).
* Run [Email Preflight](/email-editor/email-preflight) and send a test to yourself before a large campaign.
* Keep ChatGPT confirmation controls enabled. Claims, audience, sender, and timing remain your decisions.

## Custom MCP fallback

If your workspace does not use the public plugin but allows custom MCP connections, add this Remote MCP URL:

```text theme={null}
https://migma.ai/mcp
```

Complete the same browser approval flow. Do not paste a Migma API key into ChatGPT. See [Migma MCP server](/mcp-server) for managed connector details.

## Disconnect or revoke access

1. In ChatGPT, open **Settings → Apps**, find Migma, and disconnect it.
2. In Migma, open **Settings → Developers → API Keys**.
3. Find the ChatGPT connection key, then revoke it.

Disconnecting ChatGPT and revoking the Migma key are separate controls. Revoke the Migma key when you want to invalidate its access immediately.

## Troubleshooting

| Problem | Fix |
| - | - |
| Migma does not appear in Plugins | Check plan, region, role, and workspace plugin settings. Ask a workspace admin to enable Migma if needed. |
| Migma listing shows no Connect action | Select **Try now**, start a chat, then invoke `@Migma`. ChatGPT may request connection on first use. |
| Browser approval does not open | Disconnect Migma under **Settings → Apps**, then reconnect from the plugin listing. |
| ChatGPT says authentication is required | Invoke `@Migma` again and finish browser approval. |
| Migma is connected but not selected | Mention `@Migma`, or click **+ → More** and select Migma. |
| Tools look stale after approval | Start a new chat, then invoke `@Migma` again. |
| ChatGPT asks for `projectId` | Ask Migma to list your brands, then use the selected brand's project ID. |

For current ChatGPT product behavior, see [OpenAI's plugin guide](https://help.openai.com/en/articles/20001256) and [Apps in ChatGPT](https://help.openai.com/en/articles/11487775-connectors-in-chatgpt).

## When to use what

* **ChatGPT + Migma**: plan, design, import lists, and launch from one conversation.
* **Migma web app**: visual canvas control without plugin setup.
* **[Claude + Migma](/tutorials/connect-migma-to-claude-code)**: use the same workflow in Claude, with optional Claude design import.
* **[API](/api-reference/introduction), [SDK](/sdk), or [CLI](/cli)**: use Migma from application code or CI.

## Next

<CardGroup>
  <Card title="ChatGPT setup reference" icon="message-circle" href="/agents/mcp-chatgpt">
    Compare the public plugin and custom MCP fallback.
  </Card>

  <Card title="MCP permissions" icon="shield-check" href="/security/mcp">
    Review access, approval, and revocation before connecting.
  </Card>

  <Card title="Migma MCP server" icon="server" href="/mcp-server">
    See hosted MCP behavior and troubleshooting.
  </Card>
</CardGroup>


# Use Migma with Claude Code and Desktop
Source: https://docs.migma.ai/tutorials/connect-migma-to-claude-code

Connect Migma to Claude Code or Claude Desktop through Remote MCP and browser OAuth, then prepare emails, audiences, campaigns, and reports from Claude.

<Frame>
  <img alt="Illustration showing Migma connected to Claude Code and Claude Desktop" />
</Frame>

Connect Migma once, then use it from Claude Code or Claude Desktop to design branded emails, manage opted-in contacts, prepare campaigns, and read results. Browser OAuth handles access, so you do not paste an API key into Claude.

<Info>
  Both setup paths use Migma Remote MCP at `https://migma.ai/mcp`. Choose the section for the Claude app you use.
</Info>

## Start email marketing with Claude

Copy this prompt into Claude Code or Claude Desktop:

```text theme={null}
Set up Migma so you can run my email marketing.
Read https://docs.migma.ai/tutorials/connect-migma-to-claude-code and connect with full access. I'll approve in my browser.
Then show me my brands and suggest what we should do first.
```

## Before you start

You need:

* A Migma account.
* Claude Code installed and signed in, or access to custom connectors in Claude Desktop.
* A browser on the same computer for Migma approval.

For Claude Code, check the installation:

```bash theme={null}
claude --version
```

## Connect with Claude Code

<Steps>
  <Step title="Add Migma">
    Run this command in your terminal:

    ```bash theme={null}
    claude mcp add --scope user --transport http migma https://migma.ai/mcp
    ```

    `--scope user` makes Migma available in every local Claude Code project for your user account. Use `--scope local` instead when you want it only in the current project.

    Confirm the saved configuration:

    ```bash theme={null}
    claude mcp get migma
    ```

    <Frame>
      <img alt="Illustration showing the Claude Code command that adds Migma as a user-scoped HTTP MCP server" />
    </Frame>
  </Step>

  <Step title="Approve the connection">
    Start Claude Code, then enter:

    ```text theme={null}
    /mcp
    ```

    Choose **Migma**, select the authentication action, and follow the browser link. Sign in to Migma if needed.

    Review every requested permission before approving. `email:send` allows test and live sends. Keep Claude Code's confirmation controls enabled and approve only when you trust the session to act for you.

    <Frame>
      <img alt="Illustration showing Migma permission groups and the Approve connection button for Claude Code" />
    </Frame>

    Migma creates the scoped connection key automatically. No key needs to be copied into a command or chat.
  </Step>

  <Step title="See your account">
    Run `/mcp` again and confirm **Migma** shows as connected. Then ask:

    ```text theme={null}
    Show my Migma context and suggest what we should do first.
    ```

    Claude shows your workspaces, brands, plan, and sending domains, then suggests the first useful step.

    <Frame>
      <img alt="Illustration showing Migma connected in Claude Code and the account context with brands and suggestions" />
    </Frame>
  </Step>
</Steps>

## Connect with Claude Desktop

<Steps>
  <Step title="Open the connector menu">
    In a Claude conversation, click **+**, then choose **Connectors → Add connector → Add custom connector**.

    You can also open **Customize → Connectors**, click **+**, then choose **Add custom connector**.

    <Frame>
      <img alt="Illustration showing the Claude Desktop menus for Connectors, Add connector, and Add custom connector" />
    </Frame>
  </Step>

  <Step title="Add Migma">
    Enter:

    * **Name:** `Migma`
    * **Remote MCP server URL:** `https://migma.ai/mcp`

    Leave OAuth Client ID and OAuth Client Secret empty. Keep individual sign-in enabled, then click **Add**.

    <Frame>
      <img alt="Illustration showing Migma and its Remote MCP URL in Claude Desktop's Add custom connector dialog" />
    </Frame>
  </Step>

  <Step title="Approve Migma access">
    Select **Migma**, click **Connect**, and follow the browser window. Sign in to Migma if needed.

    Review every requested permission before approving. `email:send` allows test and live sends. Approve only when you trust the Claude session to act for you.

    <Frame>
      <img alt="Illustration showing Migma permissions and the Approve connection button for Claude Desktop" />
    </Frame>
  </Step>

  <Step title="Enable Migma in the conversation">
    Click **+ → Connectors**, then turn on **Migma**. The connector should show as enabled in the current conversation.

    <Frame>
      <img alt="Illustration based on the Claude Desktop connector menu showing the Migma connector enabled" />
    </Frame>
  </Step>

  <Step title="Send a first request">
    Start with a draft:

    ```text theme={null}
    Create 3 email designs for our Shopify store Allbirds using Migma.
    Keep them as editable drafts and show me each preview.
    ```

    <Frame>
      <img alt="Illustration of four coordinated emails ready for review on the Migma canvas" />
    </Frame>
  </Step>
</Steps>

<Info>
  On Claude Team or Enterprise, an organization owner may need to add the custom connector first. Each member then connects their own Migma account.
</Info>

## Why Claude alone is not enough

A Claude draft is not a campaign:

* Brand fonts, colors, logos, and knowledge need to persist across sends.
* Browser HTML is not email-safe HTML. Outlook, Gmail, and Apple Mail render differently.
* Marketing sends need opted-in contacts, a verified sender, unsubscribes, and your approval.
* Results live in campaign stats, not in a chat thread.

Migma owns those steps. Claude stays where you plan and ask.

## Run the marketing workflow

<Steps>
  <Step title="Pick a brand">
    Ask Claude to list your brands and choose one. Every later Migma action needs that brand. If Claude asks for a project ID, that is the brand handle used by the API. For a new brand, ask Migma to import it from the website.
  </Step>

  <Step title="Save lasting brand facts">
    When you share tone, products, offers, policies, or FAQs that should persist, ask Claude to save them to the Migma knowledge base. Those facts improve later emails.
  </Step>

  <Step title="Design emails and show drafts first">
    Ask for one email or a short series. Claude should generate the work, wait until it is ready, then show preview images and canvas links. Open a canvas link for visual edits in Migma. Run compatibility, deliverability, or spam checks after you have reviewed the design.
  </Step>

  <Step title="Import or build the audience">
    Upload or paste an opted-in contact CSV and name the list. Ask Claude to use one contact import with the full CSV text. You can also create a segment from contacts already in Migma.
  </Step>

  <Step title="Confirm the sender">
    Campaigns need a sending domain and From address. Ask Claude to list your domains. If none are ready, set up a domain you own, buy one, or start with a managed Migma address. See [Sending domains](/sending-domains/overview).
  </Step>

  <Step title="Check and prepare the campaign">
    After you approve a draft, ask for a test send, inbox checks, or a small edit. Then create a **draft** campaign with subject, sender, and recipients. Ask Claude to wait for approval before any live send or schedule. You can also finish launch in the [Campaigns](/campaigns/send-campaign) UI.
  </Step>

  <Step title="Read results">
    After sending, ask for campaign stats and delivery logs. Clicks are a stronger signal than opens. Use what worked to improve the next brief. See [Track results](/campaigns/track-results).
  </Step>
</Steps>

Campaigns send one approved email to an audience. Use an [email series](/creating-emails/email-series) when you need a connected sequence drafted together. See [Campaigns vs series](/campaigns/campaigns-vs-email-series).

## Prompts worth saving

### Design one email

```text theme={null}
Use Migma for brand [name].
Create one editable marketing email.
Audience: [who]
Goal: [what they should do]
Facts only: [approved claims and URLs]
One primary CTA. Do not invent metrics.
Show preview images and the canvas link as soon as they are ready.
Do not validate or send yet.
```

### Design a series

```text theme={null}
Use Migma for brand [name].
Prepare a three-email onboarding series.
Email 1: first value
Email 2: remove setup friction
Email 3: invite the next action
Keep them as editable drafts and show each preview when ready.
```

### Save brand facts

```text theme={null}
Save this to the Migma knowledge base for [brand]:
We never invent discounts. Primary CTA is "Shop the collection".
Tone is direct and short. Footer always includes shipping and returns.
```

### Import a CSV list

```text theme={null}
Use Migma for brand [name].
Import this CSV into a list named "[list name]".
These contacts opted in on our site.
Use one contact import with the full CSV text.
Report created, updated, skipped, and failed counts.
Do not convert the CSV to JSON contacts.
```

### Test, then prepare a campaign

```text theme={null}
Send a test of email [email id] to me@company.com.
```

```text theme={null}
Use Migma for brand [name].
Create a campaign draft from email [email id or canvas link].
Recipients: list or segment [name].
Subject: [subject]
Sender: [from name / domain if known]
Keep it in draft. Show recipient count, subject, and sender, then wait for my approval.
```

### Send after approval

```text theme={null}
Send the campaign now.
Or: schedule it for [date] [time] [timezone].
Confirm when it starts, then show stats when available.
```

### Read performance

```text theme={null}
Use Migma. Show stats and recent delivery logs for campaign [name or id].
Highlight opens, clicks, bounces, and complaints in plain language.
```

Run inbox checks only when you ask, or as a last step before send:

```text theme={null}
Run inbox checks for email [email id].
Separate confirmed errors, warnings, and checks not available.
Do not auto-fix. Recommend the smallest changes first.
```

## What Claude should and should not do

| Do | Do not |
| - | - |
| Start by listing brands or designing | Paste API keys into chat |
| Show preview images before checks | Run preflight before the first reveal |
| Import CSV with one contact import | Convert CSV rows to JSON contacts |
| Ask before live send or schedule | Guess the audience, sender, or send time |
| Save lasting facts to the knowledge base | Invent product claims or metrics |
| Use opted-in lists only | Import purchased, scraped, or cold contacts |

Export instead of sending in Migma when the campaign lives in another email platform. Available formats and destinations include HTML, PNG, PDF, Klaviyo, Mailchimp, and HubSpot. See [Export options](/email-editor/export-options).

## Sending rules that still apply

* Send only to contacts with marketing consent. See [What you can send](/get-started/what-you-can-send).
* Use a verified sending domain before live campaigns. See [Sending domains](/sending-domains/overview).
* Prefer [Email Preflight](/email-editor/email-preflight) and a test send to yourself before a large campaign.
* Keep a human in the loop. Claims, audience, sender, and timing remain your decision.

## Already designed in Claude?

If Claude produced a React or JSX email as a `.zip`, import it in Migma:

1. Open **Create**, select **+**, then choose **Import Claude design**.
2. Pick **Create editable email** to keep the direction, or **Create brand version** to apply your Migma brand.
3. Upload the `.zip` and review it on the canvas.

See [Claude Design to Email](/creating-emails/claude-design). After import, the same campaign workflow applies.

## When to use what

* **Claude + Migma**: plan, design, import lists, and launch from one conversation.
* **Migma web app**: get visual control on the canvas without connector setup.
* **[ChatGPT + Migma](/tutorials/connect-migma-to-chatgpt)**: run the same workflow in ChatGPT.
* **[API](/api-reference/introduction), [SDK](/sdk), or [CLI](/cli)**: build automation and CI workflows.

## Tools Claude uses

| Job | Tools |
| - | - |
| Brands | `migma_list_projects`, `migma_get_project`, `migma_import_brand` |
| Knowledge | `migma_add_knowledge_base`, `migma_list_knowledge_base` |
| Design | `migma_generate_email`, `migma_import_html`, `migma_get_generation_status`, `migma_get_email`, `migma_edit_email` |
| Audience | `migma_create_contact_import`, `migma_list_contacts`, `migma_list_tags`, `migma_list_segments` |
| Sender | `migma_list_domains`, `migma_setup_domain` |
| Test and campaign | `migma_send_test_email`, `migma_create_campaign`, `migma_send_campaign`, `migma_schedule_campaign` |
| Results | `migma_get_campaign_stats`, `migma_get_campaign_logs` |
| Checks | `migma_validate_email`, `migma_validate_compatibility`, `migma_validate_deliverability` |

Guided MCP recipes: `launch_email_campaign`, `build_segment_and_send`, `import_brand_and_generate`.

## What you can ask Claude to do

<CardGroup>
  <Card title="Create one email or a series" icon="envelopes-bulk">
    Ask for drafts, wait for preview images, then open the canvas to review them together.
  </Card>

  <Card title="Use lasting brand context" icon="palette">
    Work with saved logos, colors, fonts, products, voice, references, and approved facts.
  </Card>

  <Card title="Prepare a campaign" icon="bullhorn">
    Work with opted-in contacts, sender details, and a campaign draft. Keep live sending behind approval.
  </Card>

  <Card title="Read results" icon="chart-line">
    Ask for campaign stats and delivery logs after sending.
  </Card>
</CardGroup>

## Optional: install Migma skills

Migma skills add guided workflows and setup instructions to Claude Code:

```bash theme={null}
claude plugin marketplace add MigmaAI/migma-skills
claude plugin install migma@migma-plugins
```

Run `/reload-plugins` inside Claude Code after installation. The plugin can also provide Migma MCP; Claude Code de-duplicates servers that point to the same endpoint.

## Disconnect or revoke access

For Claude Code, remove the saved server:

```bash theme={null}
claude mcp remove --scope user migma
```

For Claude Desktop, open **Customize → Connectors**, find **Migma**, and disconnect it.

Removing the connector does not replace revocation. In Migma, open **Settings → Developers → API Keys** and revoke the Claude connection key. You can also clear authentication from Claude Code's `/mcp` menu.

## Troubleshooting

| Problem | Fix |
| - | - |
| Migma does not appear in `/mcp` | Run `claude mcp list`, then run the add command again from a normal terminal. |
| Claude Desktop does not show Add custom connector | Check whether your plan or organization allows custom connectors. Team and Enterprise owners may need to add it first. |
| Migma is connected but unavailable in a Desktop chat | Click **+ → Connectors** and turn on Migma for that conversation. |
| Migma says authentication is required | Open `/mcp`, choose Migma, and complete browser approval. |
| Browser does not open | Copy the authorization URL shown by Claude Code and open it manually. |
| Browser callback shows a connection error | Copy the full callback URL from the browser address bar and paste it into Claude Code when prompted. |
| Tools look stale after approval | Start a new Claude Code session, then check `/mcp` again. |
| Claude asks for `projectId` | Ask Migma to list your brands, then use the selected brand's project ID. |

For product-specific behavior, see [Anthropic's Claude Code MCP guide](https://code.claude.com/docs/en/mcp) and [Claude custom connector guide](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp).

## Next

<CardGroup>
  <Card title="How Migma works" icon="route" href="/get-started/setup-wizard">
    See how brand, canvas review, inbox checks, and sending fit together.
  </Card>

  <Card title="Claude setup reference" icon="terminal" href="/agents/mcp-claude">
    Compare Claude Code, Claude.ai, and Claude Desktop setup.
  </Card>

  <Card title="MCP permissions" icon="shield-check" href="/security/mcp">
    Review access, approval, and revocation before connecting.
  </Card>

  <Card title="Migma MCP server" icon="server" href="/mcp-server">
    See available workflows, security guidance, and troubleshooting.
  </Card>
</CardGroup>


# Send Emails from OpenClaw
Source: https://docs.migma.ai/tutorials/send-emails-from-openclaw

OpenClaw is an open-source AI personal assistant that runs on your own devices and integrates with messaging platforms like WhatsApp, Telegram, Discord, and Slack.

## Getting started

[OpenClaw](https://openclaw.ai/) is an open-source AI personal assistant that runs on your own devices and integrates with messaging platforms like WhatsApp, Telegram, Discord, and Slack. By adding Migma to OpenClaw, your agent gains the ability to design professional emails with AI and send them instantly — no coding, no ESP dashboard.

There are two ways to integrate Migma with OpenClaw: using the official Migma skill or creating a custom skill.

## Option 1: Official Migma Skill (Recommended)

The easiest way to add email capabilities to OpenClaw is by installing the official Migma skill from [ClawHub](https://clawhub.com/migma). This skill is maintained by the Migma team and provides comprehensive email functionality.

### Installation

Install the skill using the OpenClaw CLI:

```bash theme={null}
openclaw skills install MigmaAI/migma-skills/skills/migma
```

Or install via ClawHub:

```bash theme={null}
npx clawhub@latest install migma
```

### Configuration

Add your Migma API key to the skill configuration in `~/.openclaw/openclaw.json`:

```json theme={null}
{
  "skills": {
    "entries": {
      "migma": {
        "enabled": true,
        "env": {
          "MIGMA_API_KEY": "your_migma_api_key",
          "MIGMA_PROJECT_ID": "your_project_id"
        }
      }
    }
  }
}
```

Get access with `migma login` or [agent registration](/agent-registration). Settings keys are for CI only.

### Features

The official skill includes:

* **AI email generation:** Describe what you want and get a professional, on-brand email in seconds
* **Instant sending:** Send through a [managed domain](/sending-domains/overview) — no DNS setup. Connect [external providers](/integrations/email-service-providers) like SES or Resend.
* **[Validation](/email-editor/email-preflight):** Check deliverability, spam score, link integrity, and client compatibility before sending
* **[Audience management](/audience/overview):** Add contacts, create tags and segments, [bulk import from CSV](/audience/csv-upload)
* **Batch campaigns:** Send to an entire tag or segment in one command
* **Platform export:** Export to [Klaviyo](/integrations/klaviyo), [Mailchimp](/integrations/mailchimp), HubSpot, PDF, or PNG. See [export options](/email-editor/export-options).
* **[Brand import](/get-started/configure-brand):** Import logos, colors, fonts, and voice from any website automatically
* **Personalization:** Contacts and subscriber data included automatically

### One-time setup

Before your agent can send emails, set up an instant sending domain:

<Steps>
  <Step title="Create a managed domain">
    Tell your agent: *"Set up a sending domain for mycompany"*

    Or do it manually in Migma: **Settings → Sending Domains → Quick tab** → type a prefix like `mycompany`.

    Your sending address will be: `hello@mycompany.migma.email` — verified instantly, no DNS needed.
  </Step>

  <Step title="Set a default project">
    Tell your agent: *"List my projects and set one as default"*

    A project holds your brand identity (logo, colors, fonts, voice). If you don't have one yet, ask: *"Import our brand from [https://yourbrand.com](https://yourbrand.com)"*
  </Step>
</Steps>

<Tip>
  Want to send from your own domain (e.g. `hello@yourdomain.com`)? See [Add a Custom Domain](/sending-domains/add-domain) for DNS setup.
</Tip>

### Verify installation

Check that the skill is loaded:

```bash theme={null}
openclaw skills list --eligible
```

You should see `migma` in the list of available skills.

## Option 2: Custom Skill

For more control over the integration, you can create a custom Migma skill. Skills are directories containing a `SKILL.md` file with instructions for OpenClaw.

### Create the skill directory

Create a new skill in your OpenClaw workspace:

```bash theme={null}
mkdir -p ~/.openclaw/skills/migma
```

### Create the skill file

Create `~/.openclaw/skills/migma/SKILL.md` with the following content:

````markdown theme={null}
---
name: migma
description: Generate, send, validate, and export emails from the terminal; manage contacts, segments, domains, and webhooks with Migma.
requires:
  env:
    - MIGMA_API_KEY
---

# Migma

You can generate, send, and manage emails using the Migma API. Use the `exec` tool to run curl commands against the API.

## API Base URL

```text
https://api.migma.ai/v1
```

## Authentication

Include your API key in the Authorization header:

```text
Authorization: Bearer $MIGMA_API_KEY
```

## Common Operations

### Create a managed sending domain (instant, no DNS)

```bash
curl -s -X POST -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prefix": "mycompany"}' \
  https://api.migma.ai/v1/domains/managed
```

This gives you `hello@mycompany.migma.email` — ready to send immediately.

### Generate an email with AI

```bash
curl -s -X POST -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Welcome email for new subscribers", "projectId": "YOUR_PROJECT_ID"}' \
  https://api.migma.ai/v1/projects/emails/generate
```

Save the returned `conversationId`, then poll until generation completes:

```bash
curl -s -H "Authorization: Bearer $MIGMA_API_KEY" \
  https://api.migma.ai/v1/projects/emails/CONVERSATION_ID/status
```

Completed responses include `result.emails[]`. Use one email's `emailId` to fetch, edit, test-send, or send it:

```bash
curl -s -H "Authorization: Bearer $MIGMA_API_KEY" \
  https://api.migma.ai/v1/emails/EMAIL_ID
```

### Edit an email with a prompt

```bash
curl -s -X POST -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "Make this welcome email shorter and more transactional"}' \
  https://api.migma.ai/v1/emails/EMAIL_ID/edit
```

The response returns updated `html`, `subject`, and `screenshotUrl`.

### Send an email

```bash
curl -s -X POST -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "recipientType": "email",
    "recipientEmail": "recipient@example.com",
    "from": "hello@mycompany.migma.email",
    "fromName": "My Company",
    "subject": "Hello from OpenClaw",
    "emailId": "EMAIL_ID"
  }' \
  https://api.migma.ai/v1/sending
```

### List projects

```bash
curl -s -H "Authorization: Bearer $MIGMA_API_KEY" \
  https://api.migma.ai/v1/projects
```

### Add a contact

```bash
curl -s -X POST -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "john@example.com", "firstName": "John", "lastName": "Doe"}' \
  https://api.migma.ai/v1/subscribers
```
````

### Configure the skill

Add your Migma API key to the skill configuration in `~/.openclaw/openclaw.json`:

```json theme={null}
{
  "skills": {
    "entries": {
      "migma": {
        "enabled": true,
        "env": {
          "MIGMA_API_KEY": "your_migma_api_key"
        }
      }
    }
  }
}
```

### Verify the skill

Check that the skill is loaded:

```bash theme={null}
openclaw skills list --eligible
```

You should see `migma` in the list of available skills.

## Example use cases

Once Migma is integrated with OpenClaw, you can ask your agent to:

* *"Create a welcome email for new subscribers"*
* *"Create a three-email onboarding series and show me each email ID"*
* *"Update the welcome email to sound more transactional"*
* *"Design a Black Friday sale email with 30% off"*
* *"Send that email to [sarah@example.com](mailto:sarah@example.com)"*
* *"Check if this email will land in spam"*
* *"Send our newsletter to the VIP segment"*
* *"Export this email to Klaviyo"*
* *"Import our brand from [https://ourwebsite.com](https://ourwebsite.com)"*
* *"Add [john@example.com](mailto:john@example.com) to our contacts"*
* *"Create a product launch email, validate it, then send to our launch list"*

## Real-time notifications

For proactive handling, combine Migma webhooks with OpenClaw's webhook support. OpenClaw can react when email generation completes or a subscriber unsubscribes.

1. Set up a webhook endpoint in OpenClaw (see [OpenClaw webhook documentation](https://docs.openclaw.ai/automation/webhook))

2. Register the webhook with Migma:

```bash theme={null}
curl -X POST -H "Authorization: Bearer $MIGMA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-openclaw-webhook-url",
    "events": ["email.generation.completed", "subscriber.unsubscribed"]
  }' \
  https://api.migma.ai/v1/webhooks
```

Now OpenClaw receives those workflow events, allowing your agent to follow up or report progress.

## Resources

<CardGroup>
  <Card title="Official Migma Skill" icon="box-open" href="https://clawhub.com/migma">
    Install from ClawHub
  </Card>

  <Card title="CLI Documentation" icon="terminal" href="/cli">
    Full command reference
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Endpoint documentation
  </Card>
</CardGroup>

<CardGroup>
  <Card title="Node.js SDK" icon="npm" href="/sdk">
    TypeScript SDK guide
  </Card>

  <Card title="OpenClaw Docs" icon="book" href="https://docs.openclaw.ai">
    OpenClaw documentation
  </Card>

  <Card title="Discord" icon="discord" href="https://discord.gg/ZB6c2meCUA">
    Community support
  </Card>
</CardGroup>


# How to Send Localized Emails from Migma?
Source: https://docs.migma.ai/tutorials/send-localized-emails

Send each subscriber your email in their language. Add a language to your contacts, generate in multiple languages, and Migma handles the rest.

Migma lets you send a single campaign that automatically renders in each subscriber's language. No duplicate campaigns, no manual filtering — just one send.

Here's how it works in three steps.

***

## 1. Add Language to Your Contacts

Every contact in Migma can have a `language` field. You can set it in two ways:

<CardGroup>
  <Card title="CSV Import" icon="file-csv">
    Include a `language` column in your CSV with [ISO 639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) codes (e.g. `en`, `es`, `fr`, `de`). Migma maps it automatically during import.
  </Card>

  <Card title="Manual Edit" icon="pen">
    Open any contact and set their language from the contact details panel.
  </Card>
</CardGroup>

<Tip>
  **Auto-inference from country** — If a contact has a `country` but no explicit `language`, Migma infers the language automatically. For example, a contact in Spain gets `es`, France gets `fr`, and Germany gets `de`.
</Tip>

### Common Country → Language Mappings

| Country | Code | Language |
| - | - | - |
| United States | US | `en` |
| United Kingdom | GB | `en` |
| Spain | ES | `es` |
| Mexico | MX | `es` |
| France | FR | `fr` |
| Germany | DE | `de` |
| Italy | IT | `it` |
| Portugal | PT | `pt` |
| Brazil | BR | `pt` |
| Netherlands | NL | `nl` |
| Japan | JP | `ja` |
| South Korea | KR | `ko` |

***

## 2. Generate Your Email in Multiple Languages

When creating an email, use the **language selector** in the generation panel to pick the languages you want (up to 4).

Write your prompt as usual — Migma's AI generates the email with all selected language versions built into a single template. Each version is fully localized, not just translated: subject lines, CTAs, and copy all adapt naturally.

<Info>
  You only write one prompt. The AI handles the rest — no need to generate each language separately.
</Info>

***

## 3. Send to Your Audience

When you send the campaign, Migma checks each subscriber's `language` field and renders the matching version automatically.

* A subscriber with `language: es` sees the Spanish version
* A subscriber with `language: fr` sees the French version
* Subscribers without a language set receive the **default** (first) language

That's it — one campaign, multiple languages, zero manual work.

***

## Learn More

<CardGroup>
  <Card title="Multi-Language Contacts" icon="users" href="/audience/multi-language">
    Managing language preferences for your audience
  </Card>

  <Card title="CSV Upload Guide" icon="file-csv" href="/audience/csv-upload">
    How to import contacts with language data
  </Card>
</CardGroup>


# Events & Webhooks
Source: https://docs.migma.ai/webhooks

Subscribe an application or workflow tool to Migma webhook events, verify signatures, handle retries and duplicates, and monitor delivery failures.

## Overview

Use webhooks when your integration needs to react to Migma activity without polling.
Migma creates an event, finds active webhook subscriptions for that event type, and sends an HTTPS `POST` request to your endpoint.

Common uses:

* Continue an automation when API email generation finishes
* Sync contact changes into a CRM or data warehouse
* Alert a team when generation fails
* Track unsubscribe activity outside Migma

<Info>
  Webhooks are outbound notifications from Migma to your system. They are not an inbound custom-events API.
</Info>

<Warning>
  Most webhook events are emitted by API v1 activity. `subscriber.unsubscribed` also fires from real unsubscribe paths, including one-click unsubscribe, mailto unsubscribe, and dashboard status changes.
</Warning>

## Set up a webhook

<Steps>
  <Step title="Create an HTTPS endpoint">
    Your endpoint must accept `POST` requests and return a `2xx` status when the event is accepted.

    ```js theme={null}
    import express from 'express';

    const app = express();

    app.post('/webhooks/migma', express.raw({ type: 'application/json' }), (req, res) => {
      const event = JSON.parse(req.body.toString('utf8'));

      console.log(event.type, event.id);
      res.sendStatus(204);
    });
    ```
  </Step>

  <Step title="Create the webhook in Migma">
    In the dashboard, go to **Settings -> Developers -> Webhooks**, add your endpoint URL, and choose the events to receive.

    You can also create a webhook through the API:

    ```bash theme={null}
    curl https://api.migma.ai/v1/webhooks \
      -H "Authorization: Bearer $MIGMA_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "url": "https://example.com/webhooks/migma",
        "events": ["email.generation.completed", "subscriber.unsubscribed"],
        "description": "Production automation webhook"
      }'
    ```
  </Step>

  <Step title="Store the signing secret">
    `POST /v1/webhooks` returns the signing `secret` once, in the create response. Store it securely.

    `GET /v1/webhooks/{webhookId}` only returns `secretConfigured`; it does not return the secret again. To rotate a secret, delete and recreate the webhook.
  </Step>

  <Step title="Send a test event">
    Use the dashboard test action or `POST /v1/webhooks/{webhookId}/test` to confirm your endpoint receives a signed event and returns `2xx`.
  </Step>
</Steps>

## Events Migma emits

Use `GET /v1/webhooks/events` to list the event types available to your account.
For production automations, build around these emitted events:

| Event | Source | Payload highlights |
| - | - | - |
| `email.generation.started` | `POST /v1/projects/emails/generate` starts async generation | `conversationId`, `projectId`, `prompt`, `model`, `languages`, `count` |
| `email.generation.completed` | API generation reaches completed status | `conversationId`, `projectId`, `count`, `languages` |
| `email.generation.failed` | API generation fails | `conversationId`, `projectId`, `error` |
| `email.test.sent` | A test email is sent through the API | `conversationId`, `recipient`, `messageId`, `sentAt`, optional `emailId` |
| `project.import.started` | `POST /v1/projects/import` starts a brand import | `projectId`, `urls`, `domain` |
| `subscriber.added` | `POST /v1/contacts` creates a contact | `subscriberId`, `projectId`, `email`, `tags` |
| `subscriber.updated` | `PATCH /v1/contacts/{id}` updates a contact | `subscriberId`, `projectId`, `email` |
| `subscriber.unsubscribed` | A contact unsubscribes or is deleted | `subscriberId`, `projectId`, `email`, `action`, optional `source` |
| `subscriber.bulk_imported` | A contact bulk import completes | `projectId`, `success`, `failed`, `updated`, optional `jobId` |

<Note>
  Brand imports currently emit `project.import.started`. To detect completion, poll `GET /v1/projects/import/{projectId}/status` until the import status is `active` or `error`.
</Note>

<Note>
  Email engagement events such as opens, clicks, bounces, and complaints are not delivered through this webhook system. Use campaign and sending analytics pages for those metrics.
</Note>

## Payload format

Every delivery uses the same envelope:

```json theme={null}
{
  "id": "666f2f7b9a9b6d84f1b2c345",
  "type": "email.generation.completed",
  "timestamp": "2026-06-27T12:34:56.789Z",
  "apiVersion": "v1",
  "data": {
    "conversationId": "665f1f0b8c2a9e4d8f123456",
    "projectId": "665f1e928c2a9e4d8f123123",
    "count": 3,
    "languages": ["en"]
  },
  "metadata": {
    "userId": "665f1d018c2a9e4d8f122222",
    "projectId": "665f1e928c2a9e4d8f123123",
    "conversationId": "665f1f0b8c2a9e4d8f123456"
  }
}
```

| Field | Meaning |
| - | - |
| `id` | Unique event ID. Store it for idempotency. |
| `type` | Event type, such as `email.generation.completed`. |
| `timestamp` | Event creation time in ISO 8601 format. |
| `apiVersion` | Webhook payload version. |
| `data` | Event-specific payload. |
| `metadata` | Account and resource context used for routing. |

## Delivery headers

Migma includes these headers with delivery requests:

| Header | Value |
| - | - |
| `Content-Type` | `application/json` |
| `User-Agent` | `Migma-Webhooks/1.0` |
| `X-Migma-Signature` | HMAC SHA-256 hex digest of the raw JSON body |
| `X-Migma-Event-Type` | Event type |
| `X-Migma-Event-Id` | Event ID |
| `X-Migma-Delivery-Id` | Delivery attempt ID |
| `X-Migma-Test` | Present on test deliveries |

Custom headers configured on the webhook are also included.

## Verify signatures

Always verify `X-Migma-Signature` before processing a webhook. Compute the HMAC over the exact raw request body, not a parsed and re-serialized JSON object.

```js theme={null}
import crypto from 'crypto';
import express from 'express';

const app = express();

function verifyMigmaSignature(rawBody, signature, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');

  if (!signature || signature.length !== expected.length) {
    return false;
  }

  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
}

app.post('/webhooks/migma', express.raw({ type: 'application/json' }), async (req, res) => {
  const signature = req.header('X-Migma-Signature');
  const valid = verifyMigmaSignature(req.body, signature, process.env.MIGMA_WEBHOOK_SECRET);

  if (!valid) {
    return res.status(401).send('Invalid signature');
  }

  const event = JSON.parse(req.body.toString('utf8'));
  await handleMigmaEvent(event);

  res.sendStatus(204);
});
```

```python theme={null}
import hashlib
import hmac
import os
from flask import Flask, request

app = Flask(__name__)

def verify_migma_signature(raw_body, signature, secret):
    expected = hmac.new(
        secret.encode("utf-8"),
        raw_body,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature or "", expected)

@app.post("/webhooks/migma")
def migma_webhook():
    raw_body = request.get_data()
    signature = request.headers.get("X-Migma-Signature")

    if not verify_migma_signature(raw_body, signature, os.environ["MIGMA_WEBHOOK_SECRET"]):
        return "Invalid signature", 401

    event = request.get_json()
    handle_migma_event(event)
    return "", 204
```

## Delivery and retries

Webhook delivery is non-blocking. Migma returns API responses without waiting for your webhook endpoint.

Delivery behavior:

* `2xx` response: delivery succeeds.
* Non-`2xx` response or timeout: delivery is retried with backoff.
* Timeout: each attempt times out after 10 seconds.
* Attempts: Migma stops after three total delivery attempts.
* Ordering: do not rely on strict ordering across different event types or webhooks.
* Duplicate handling: delivery is at least once, so process by `id` idempotently.

Keep handlers small. Acknowledge the event quickly, enqueue your own work, then process it asynchronously.

```js theme={null}
const processed = new Set();

async function handleMigmaEvent(event) {
  if (processed.has(event.id)) {
    return;
  }

  switch (event.type) {
    case 'email.generation.completed':
      await queueGeneratedEmailSync(event.data.conversationId);
      break;
    case 'subscriber.unsubscribed':
      await crm.markUnsubscribed(event.data.email);
      break;
    default:
      console.log(`Unhandled Migma event: ${event.type}`);
  }

  processed.add(event.id);
}
```

## Monitor deliveries

Use delivery history when debugging endpoint failures:

```bash theme={null}
curl https://api.migma.ai/v1/webhooks/{webhookId}/deliveries \
  -H "Authorization: Bearer $MIGMA_API_KEY"
```

Useful endpoints:

| Endpoint | Purpose |
| - | - |
| `GET /v1/webhooks` | List configured webhooks |
| `POST /v1/webhooks` | Create a webhook |
| `PATCH /v1/webhooks/{webhookId}` | Update URL, events, active state, description, or custom headers |
| `DELETE /v1/webhooks/{webhookId}` | Delete a webhook |
| `GET /v1/webhooks/events` | List available event types |
| `POST /v1/webhooks/{webhookId}/test` | Send a test delivery |
| `GET /v1/webhooks/{webhookId}/deliveries` | Inspect recent delivery attempts |
| `GET /v1/webhooks/stats` | Get aggregate webhook delivery stats |

Webhook management requires API keys with `webhook:read` and `webhook:write` permissions.

## Troubleshooting

| Issue | Check |
| - | - |
| Signature verification fails | Use the raw request body and the secret returned when the webhook was created. |
| Test delivery fails | Confirm the URL is public HTTPS and responds within 10 seconds. |
| Duplicate processing | Store processed event IDs and make handlers idempotent. |
| No generation completion event | Confirm the email was generated through the API async generation flow. |
| No import completion event | Poll the import status endpoint; only import start is emitted as a webhook today. |
| Missing unsubscribe event | Confirm the webhook subscribes to `subscriber.unsubscribed` and is active. |

<CardGroup>
  <Card title="API Reference" icon="book" href="/api-reference/introduction">
    Review webhook endpoints, schemas, and permissions.
  </Card>

  <Card title="n8n" icon="diagram-project" href="/n8n">
    Trigger no-code automations from Migma events.
  </Card>
</CardGroup>