Send Emails with Lovable

Add email sending to an app you built in Lovable using the Brew API, wiring automations to your app’s real events without leaving your stack.

Overview

Lovable is a platform that builds full-stack web apps from natural language prompts. You can integrate Brew into any Lovable project to send on-brand emails triggered by user actions in your app.

Brew works with Lovable through its REST API. Since the API requires an API key, Lovable uses Supabase Edge Functions to keep your credentials secure.

What Brew Handles for You

Building email into an app usually means writing HTML templates, handling unsubscribes, managing bounces, and worrying about deliverability. Brew takes care of all of that so you can focus on your app.

• On-brand design without HTML - Describe your email in plain language. Brew generates production-ready, responsive emails that match your brand’s colors, fonts, logo, and tone of voice. No HTML coding or email design skills needed.
• Compliance built in - Marketing emails (both one-off Emails and Automations) automatically include a physical address and unsubscribe link in the footer. Brew’s preflight audit blocks any send that’s missing required compliance elements, keeping you aligned with CAN-SPAM and GDPR.
• Unsubscribe management - Brew handles the entire unsubscribe flow: a branded unsubscribe page, contact status updates, and automatic suppression from future marketing sends. You don’t need to build any of this yourself.
• Bounce and complaint handling - Hard bounces and spam complaints are automatically suppressed, protecting your sender reputation without any code on your end.
• Contact auto-creation - When you trigger an automation, Brew automatically creates or updates the contact record. No separate contact creation step needed in your app.
• Works across every email client - Gmail, Outlook, Apple Mail, Yahoo, mobile - email HTML is notoriously tricky. Every email Brew generates is responsive and tested across clients.
• Analytics without instrumentation - Opens, clicks, bounces, and deliverability are tracked automatically in Brew’s dashboard. No event tracking code required in your Lovable app.

Three Ways to Send Emails with Brew

Brew has three types of emails. Here’s how each one works in the context of a Lovable app:

Type	What it does	How it’s triggered
Automations	Multi-step email sequences with delays, branching, and conditions. Think welcome series, onboarding drips, or order follow-ups.	Triggered from your Lovable app via API when an event happens (user signs up, places an order, etc.)
Transactional	Single, immediate account emails like password resets and receipts.	Not generally available yet. Keep these on your current provider, see the note below.
Emails	One-time sends to a segment of your audience, what other tools call campaigns. Think newsletters, product announcements, or promotions.	Created and sent (or scheduled) inside Brew’s dashboard. Not triggered from your app.

Automations are triggered directly from your Lovable app using the setup below. Emails are designed and sent from Brew’s UI, so there’s nothing to configure in Lovable for those.

Prerequisites

Brew Account

Sign up at brew.new and set up your brand.

Verified Domain

Verify your sending domain to send emails from your own address.

API Key

Create a new API key at brew.new/settings/api. For this single-brand integration, create a brand-scoped key while the intended brand is active.

Lovable with Supabase

Connect Supabase to your Lovable project to use Edge Functions.

Connect Brew to Lovable

These steps wire your Lovable app up to trigger automations.

1. Connect Supabase to your Lovable project

   Lovable uses Supabase Edge Functions to securely handle API keys. If you haven’t connected Supabase yet, click the Supabase icon in your Lovable project and follow the authorization steps.

2. Add your Brew API key as a secret

   In your Lovable project, go to Supabase → Secrets:

   • Add a new secret with the name BREW_API_KEY
   • Paste your Brew API key as the value

   Get your API key from brew.new/settings/api.

---

Automations

Automations are multi-step email flows you design in Brew and trigger from your Lovable app when something happens, like a user signing up, placing an order, or abandoning a cart. Brew handles the entire sequence: delays, branching, follow-ups.

Set Up in Brew

1. Create your automation

   In Brew, go to the Create page, select Automation, and describe the flow you want. For example: “Create a 3-email welcome series for new users. First email welcomes them, second shares a quick-start guide, third nudges them to book a demo.”

2. Set an event ID and define your payload

   Give your automation a descriptive event ID like user_signup or order_placed. Define the payload schema (the data your app will send), for example: email, firstName, plan.

3. Publish

   Publish your automation to make it available via API.

Learn more about building automations in the Build an Automation guide.

Prompt Lovable

Copy and paste this prompt into Lovable’s chat:

Integrate Brew automation API for triggering email sequences.

API Details:
- Base URL: https://brew.new/api
- Auth: Bearer token using the BREW_API_KEY secret
- Endpoint: POST /v1/automations/triggers/{triggerEventId}/fire
  (the trigger id travels in the URL path, not the body)
- Content-Type: application/json
- Optional header: `Idempotency-Key` (recommended). See [Idempotency](/api-reference/api/idempotency) for replay behavior.

Request body format (fire):
{
  "payload": {
    "email": "[e-mail]",
    "firstName": "Jane",
    "plan": "premium"
  }
}

Response format (HTTP 202):
{
  "success": true,
  "status": "triggered",
  "triggerEventId": "tri_user_signup",
  "receivedAt": "2026-04-08T12:34:56.789Z",
  "details": {
    "triggerInstanceId": "tin_01HZ",
    "automationRunIds": ["run_abc"],
    "publishedAutomations": [
      { "automationId": "auto_welcome", "title": "Welcome flow" }
    ],
    "counts": { "automations": 1, "transactionalEmails": 0 }
  }
}

Create a Supabase Edge Function called "trigger-automation" that:
1. Reads BREW_API_KEY from environment secrets
2. Accepts triggerEventId and payload in the request body
3. Calls POST https://brew.new/api/v1/automations/triggers/${triggerEventId}/fire with:
     - Authorization: Bearer <BREW_API_KEY>
     - Idempotency-Key: <a stable per-event hash, e.g. `signup-${userId}-${eventTimestamp}`>
4. Returns response.details.automationRunIds[] (and any warnings) to the client

The "email" field is always required in the payload. triggerEventId is the
stable id returned by POST /v1/automations/triggers (or surfaced in
GET /v1/automations/triggers for integration-provisioned triggers).

Docs: https://docs.brew.new/create-emails/build-an-automation
SDK: https://docs.brew.new/sdks/typescript/agentic-cookbook (use brew.automations.triggers.fire())

Lovable will generate a Supabase Edge Function and wire it into your app automatically.

When to Use Automations

• User signup - Trigger user_signup to start a welcome series
• Onboarding - Trigger onboarding_started to send a multi-step getting started sequence
• Trial ending - Trigger trial_ending to send a reminder sequence nudging users to upgrade
• Re-engagement - Trigger user_inactive to win back users who haven’t logged in recently

---

Transactional Emails

Brew’s transactional email isn’t generally available yet.

Password resets, receipts, and account notifications have to reach unsubscribed contacts and skip the unsubscribe footer, and only a transactional send can do that. Until it ships, keep those on your current provider.

Everything event-driven on the marketing side, welcome, onboarding, trial ending, re-engagement, runs through the automations flow above today.

---

Test Your Integration

Once Lovable finishes generating the code, trigger the email flow in your app (for example, submitting a signup form). Check your email analytics in Brew to confirm the email was delivered.

Troubleshooting

Emails are not being sent

Make sure your BREW_API_KEY is correctly added in Supabase Secrets. Also verify that your sending domain is verified in Brew by checking Settings → Domains in your dashboard.

Getting a 401 Unauthorized error

Double-check that the Edge Function is reading the secret correctly. The Authorization header should be Bearer YOUR_API_KEY with no extra spaces or quotes.

Missing required payload fields

Make sure the payload includes email and every required field defined in your trigger schema. Field names are case-sensitive.

Automation not triggering

Verify that at least one bound automation is Published in Brew (Draft automations are inert). Check that the event ID in your API call matches the trigger configured in Brew. If brew.automations.triggers.fire(...) returns NO_PUBLISHED_AUTOMATION, that’s the signal. Publish at least one bound automation and retry.

Emails landing in spam

Make sure you have completed domain verification including DKIM and SPF records. We recommend using a subdomain like updates.yourdomain.com for sending.

Lovable shows build errors

Lovable may sometimes show false positive build errors. Test your app live by triggering the actual email flow. If the Edge Function deploys successfully in Supabase, the integration is likely working.

Need Help?

Our team is ready to support you at every step of your journey with Brew. Choose the option that works best for you:

Self-Service Tools

Search Documentation

Type in the “Ask any question” search bar at the top left to instantly find relevant documentation pages.

ChatGPT/Claude Integration

Click “Open in ChatGPT” at the top right of any page to explore it further with ChatGPT or Claude.

Talk to Our Team

Schedule a Call

Book time with our founders for personalized guidance on strategy, best practices, or complex implementation questions.

Call Us Directly

Need immediate assistance? Reach us at [phone] for urgent issues or time-sensitive questions.

Slack Channel

Our preferred support channel. You’ll receive an invite after signup for direct founder support and fast responses.

Email Support

Contact us at [e-mail] for detailed inquiries or if you prefer not to use Slack.