No-Code & Low-Code Integrations

Connect FormaMail to thousands of apps using our native integrations. Build automated workflows that send transactional emails and dynamically generate PDF and Excel attachments.

Overview

FormaMail provides native integrations for popular automation platforms:

Zapier Integration

Getting Started with Zapier

Available Triggers

Triggers start your Zap when an event occurs in FormaMail:

Available Actions

Actions let you perform operations in FormaMail:

Available Searches

Searches let you find existing data in FormaMail:

Common Zapier Workflows

New Form Submission → Welcome Email

Trigger: Google Forms / Typeform / Webflow Action: FormaMail - Send Email

New form submitted → Send welcome email with personalized name

Configuration:

1. Select trigger (e.g., “New Form Response” in Google Forms)
2. Add FormaMail “Send Email” action
3. Choose your welcome email template
4. Map form fields to template variables:
   • {{email}} → Form email field
   • {{name}} → Form name field
   • {{firstName}} → Form first name field

Payment Received → Invoice Email with PDF

Trigger: Stripe - Payment Succeeded Action: FormaMail - Send Email with PDF

Payment successful → Generate invoice PDF → Send via email

Configuration:

1. Trigger: Stripe “Payment Intent Succeeded”
2. Action: FormaMail “Send Email with PDF”
3. Select email template and PDF template
4. Map payment data:
   • {{invoiceNumber}} → Stripe payment ID
   • {{amount}} → Payment amount
   • {{customerName}} → Customer name

Email Bounced → Update CRM

Trigger: FormaMail - Email Bounced Action: HubSpot - Update Contact

Email bounces → Mark contact as undeliverable in CRM

Weekly Schedule → Report Email with Excel

Trigger: Schedule by Zapier (Weekly) Action: FormaMail - Send Email with Excel

Every Monday 9 AM → Generate report → Send to stakeholders

Trigger Data Fields

When FormaMail triggers fire, they provide these data fields:

{
  "event": "email.delivered",
  "timestamp": "2025-12-02T10:30:00Z",
  "data": {
    "emailLogId": "el_abc123...",
    "recipient": "user@example.com",
    "recipientName": "John Doe",
    "subject": "Your Invoice",
    "templateId": "tmpl_invoice",
    "status": "delivered"
  }
}

Make.com Integration

Getting Started with Make.com

Available Modules

Triggers (Watch Events)

Actions

Searches

Make.com Scenario Examples

Multi-Condition Email Router

Use the Router module to send different emails based on conditions:

Trigger → Router
           ├─→ [Order > $100] → Send VIP Welcome
           ├─→ [Trial User] → Send Trial Onboarding
           └─→ [Default] → Send Standard Welcome

Batch Processing with Iterator

Process multiple records with intelligent rate limiting:

1. Get Records (from database/sheet)
2. Array Aggregator
3. Iterator
4. FormaMail - Send Email
5. Sleep (rate limit buffer)

Error Handling Flow

FormaMail Send Email
    ├─→ Success → Continue workflow
    └─→ Error Handler
            ├─→ 429 Rate Limit → Wait & Retry
            └─→ 400 Bad Request → Log to Sheet

n8n Integration

Installation

npm install n8n-nodes-formamail

Setting Up Credentials

Available Nodes

FormaMail Trigger Node

Starts workflows on email events:

FormaMail Action Node

Performs operations:

n8n Workflow Examples

Multi-Step Email Sequence

┌─────────────┐     ┌──────────────┐     ┌─────────────┐
│  Webhook    │ ──→ │  Send Email  │ ──→ │   Wait 24h  │
│  (Signup)   │     │  (Welcome)   │     │             │
└─────────────┘     └──────────────┘     └──────┬──────┘
                                                │
┌─────────────┐     ┌──────────────┐     ┌──────┴──────┐
│   Wait 48h  │ ←── │  Send Email  │ ←── │ Send Email  │
│             │     │  (Follow-up) │     │ (Onboarding)│
└─────────────┘     └──────────────┘     └─────────────┘

Conditional Logic with Switch Node

┌──────────┐     ┌──────────┐     ┌────────────────────┐
│ Trigger  │ ──→ │  Switch  │ ──→ │ Customer → VIP     │
│          │     │  (type)  │     │ Partner → Partner  │
└──────────┘     └──────────┘     │ Default → Standard │
                                  └────────────────────┘

Error Handling & Retry

┌──────────────┐     ┌──────────────┐
│   FormaMail  │ ──→ │   Success    │
│  Send Email  │     │   Continue   │
└──────┬───────┘     └──────────────┘
       │
       │ (Error)
       ↓
┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│    Error     │ ──→ │   Wait 5min  │ ──→ │    Retry     │
│   Trigger    │     │              │     │  Send Email  │
└──────────────┘     └──────────────┘     └──────────────┘

Self-Hosted Benefits

• Full API Access: Use all FormaMail API endpoints
• Custom Nodes: Extend functionality as needed
• Data Privacy: Keep workflow data on your infrastructure
• Unlimited Workflows: No execution limits
• Advanced Logic: Complex branching and error handling

Native SDKs

FormaMail provides official SDKs for popular programming languages:

Node.js SDK

Package: @formamail/sdk

npm install @formamail/sdk

import { Formamail } from '@formamail/sdk';
 
const formamail = new Formamail({
  apiKey: process.env.FORMAMAIL_API_KEY!,
});
 
const result = await formamail.emails.send({
  templateId: 'tmpl_welcome',
  to: 'customer@example.com',
  toName: 'John Doe',
  variables: {
    firstName: 'John',
    accountId: '12345',
  },
});
 
console.log('Email sent:', result.id);

const result = await formamail.emails.sendWithPdf({
  templateId: 'tmpl_invoice_email',
  to: 'customer@example.com',
  pdfTemplateId: 'tmpl_invoice_pdf',
  pdfFileName: 'Invoice-001',
  variables: {
    invoiceNumber: 'INV-001',
    customerName: 'John Doe',
    total: 99.99,
  },
});

const result = await formamail.emails.sendWithExcel({
  templateId: 'tmpl_report_email',
  to: 'manager@example.com',
  excelTemplateId: 'tmpl_monthly_report',
  excelFileName: 'Monthly-Report',
  variables: {
    reportMonth: 'January 2025',
    data: [...],
  },
});

const result = await formamail.emails.sendBulk({
  templateId: 'tmpl_newsletter',
  recipients: [
    { email: 'user1@example.com', name: 'User 1', variables: { firstName: 'User' } },
    { email: 'user2@example.com', name: 'User 2', variables: { firstName: 'User' } },
  ],
  commonVariables: {
    companyName: 'Acme Corp',
  },
});
 
console.log('Batch ID:', result.batchId);

Webhook Verification (Node.js)

import { verifyWebhookSignature } from '@formamail/sdk';
 
app.post('/webhooks/formamail', express.raw({ type: 'application/json' }), (req, res) => {
  try {
    const event = verifyWebhookSignature({
      payload: req.body.toString(),
      signature: req.headers['x-formamail-signature'] as string,
      secret: process.env.WEBHOOK_SECRET!,
    });
 
    switch (event.type) {
      case 'email.delivered':
        console.log('Delivered:', event.data.emailId);
        break;
      case 'email.bounced':
        console.log('Bounced:', event.data.emailId);
        break;
    }
 
    res.status(200).send('OK');
  } catch (error) {
    res.status(400).send('Invalid signature');
  }
});

Python SDK

Package: formamail

pip install formamail

from formamail import Formamail
 
client = Formamail(api_key="your_api_key")
 
# Send email
result = client.emails.send(
    template_id="tmpl_welcome",
    to="customer@example.com",
    to_name="John Doe",
    variables={
        "firstName": "John",
        "accountId": "12345",
    },
)
 
print(f"Email sent: {result['id']}")
 
# Send with PDF
result = client.emails.send_with_pdf(
    template_id="tmpl_invoice_email",
    to="customer@example.com",
    pdf_template_id="tmpl_invoice_pdf",
    pdf_file_name="Invoice-001",
    variables={"invoiceNumber": "INV-001"},
)

from formamail import AsyncFormamail
import asyncio
 
async def main():
    async with AsyncFormamail(api_key="your_api_key") as client:
        result = await client.emails.send(
            template_id="tmpl_welcome",
            to="customer@example.com",
            variables={"firstName": "John"},
        )
        print(f"Email sent: {result['id']}")
 
asyncio.run(main())

from formamail import verify_webhook_signature, WebhookSignatureError
 
@app.route('/webhooks/formamail', methods=['POST'])
def handle_webhook():
    try:
        event = verify_webhook_signature(
            payload=request.data.decode('utf-8'),
            signature=request.headers.get('X-FormaMail-Signature'),
            secret=os.environ['WEBHOOK_SECRET'],
        )
 
        if event['type'] == 'email.delivered':
            print(f"Delivered: {event['data']['emailId']}")
 
        return 'OK', 200
    except WebhookSignatureError:
        return 'Invalid signature', 400

SDK API Reference

Client Methods

Emails Resource

Templates Resource

Webhooks Resource

Webhook Events

All integrations can subscribe to these webhook events:

Webhook Payload Format

{
  "event": "email.delivered",
  "timestamp": "2025-12-02T10:30:00.000Z",
  "data": {
    "emailLogId": "el_abc123def456",
    "recipient": "user@example.com",
    "recipientName": "John Doe",
    "subject": "Welcome to FormaMail",
    "templateId": "tmpl_welcome",
    "status": "delivered",
    "deliveredAt": "2025-12-02T10:30:00.000Z"
  }
}

Webhook Security

All webhooks include security headers for signature verification:

Authentication

OAuth 2.0 (Zapier & Make.com)

Zapier and Make.com use OAuth 2.0 for secure authentication.

Scopes:

API Keys (n8n & SDKs)

n8n and native SDKs authenticate using API keys generated in the FormaMail dashboard.

1. Go to Settings → API Keys
2. Click Create API Key
3. Copy the key (shown only once)
4. Store securely in environment variables

# .env
FORMAMAIL_API_KEY=fm_sk_xxxxxxxxxxxx

Rate Limits

Best Practices

1. API Key Security

• Store keys in environment variables
• Use platform secret managers
• Rotate keys periodically
• Use separate keys for development/production

2. Error Handling

Always implement error handling:

try {
  await formamail.emails.send({...});
} catch (error) {
  if (error.statusCode === 429) {
    // Rate limit - implement backoff
  } else if (error.statusCode === 400) {
    // Validation error - check request
  }
}

3. Webhook Verification

Always verify webhook signatures to prevent spoofing attacks.

4. Use Bulk Endpoints

For multiple recipients, use bulk send instead of individual requests:

// Bad: Many individual requests
for (const recipient of recipients) {
  await formamail.emails.send({ to: recipient.email, ... });
}
 
// Good: Single bulk request
await formamail.emails.sendBulk({
  recipients: recipients.map(r => ({ email: r.email, ... })),
});

Troubleshooting

Common Issues

401 Unauthorized

• Verify API key or OAuth token is valid
• Check key has required permissions
• Ensure header is Authorization with value Bearer YOUR_API_KEY

400 Bad Request

• Validate JSON structure
• Check required fields (templateId, to)
• Verify template exists

429 Rate Limit

• Implement exponential backoff
• Use bulk endpoints
• Contact support for limit increase

Webhook Not Receiving Events

• Verify URL is publicly accessible (HTTPS)
• Check subscription is active
• Review delivery logs in dashboard

Getting Help

• Documentation: https://docs.formamail.com
• API Reference: https://docs.formamail.com/api
• Support Email: support@formamail.com
• Status Page: status.formamail.com

Next Steps