✉️ Send Emails

Overview

Email notifications are one of the most important channels for user communication. NotificationAPI makes it easy to send personalized, professional emails with advanced features like parameters, attachments, CC/BCC, and tracking.

This guide covers everything you need to know about sending emails, from basic setup to advanced features.

Step 1: Create your account and first notification

Create your NotificationAPI account and complete the onboarding. Sign up for free.
In the dashboard, create your first notification and enable the Email channel. See the Configure Notification guide if needed.
Note the notification’s Type (e.g., welcome_email). You’ll use this later in the send step.

Step 2: Install the SDK

In the dashboard send step, the first thing you’ll need to do is install the SDK. Select the appropriate language and follow the instructions.

Install the node package using one of the following package managers:

npm install notificationapi-node-server-sdk

yarn add notificationapi-node-server-sdk

pnpm add notificationapi-node-server-sdk

pip install notificationapi_python_server_sdk

composer require notificationapi/notificationapi-php-server-sdk

go get github.com/notificationapi-com/notificationapi-go-server-sdk

dotnet add package NotificationAPI --version 0.5.0

Add the following dependency to your pom.xml file:

<dependencies>
    <dependency>
        <groupId>com.notificationapi</groupId>
        <artifactId>notificationapi-java-server-sdk</artifactId>
        <version>0.3.0</version>
    </dependency>
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.14</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.15.2</version>
    </dependency>
</dependencies>

Add the NotificationAPI class to your application - see the full Ruby implementation.

Step 3: Send an Email Notification

The next part of the send step is to send the notification from your backend. Here’s how to send an email notification by passing the email content directly:

TIP

Replace the type value (e.g., welcome_email) with the notification Type you noted in Step 1, and replace YOUR_CLIENT_ID and YOUR_CLIENT_SECRET with the values from the code sample in your NotificationAPI dashboard.

import notificationapi from 'notificationapi-node-server-sdk';

// Initialize (default US region)
// For CA region: add 'https://api.ca.notificationapi.com' after CLIENT_SECRET
// For EU region: add 'https://api.eu.notificationapi.com' after CLIENT_SECRET
notificationapi.init('YOUR_CLIENT_ID', 'YOUR_CLIENT_SECRET');

// Send email notification
notificationapi.send({
  type: 'welcome_email',
  to: {
    id: 'user123',
    email: 'user@example.com' // Required for email notifications
  },
  email: {
    subject: 'Welcome to Acme Corp',
    html: '<h1>Welcome!</h1><p>Thanks for joining Acme Corp.</p>',
    senderName: 'Acme Team',
    senderEmail: 'hello@acme.com'
  }
});

import asyncio
from notificationapi_python_server_sdk import notificationapi

# Initialize (default US region)
notificationapi.init("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")

async def send_email():
    await notificationapi.send({
        "type": "welcome_email",
        "to": {
            "id": "user123",
            "email": "user@example.com"  # Required for email notifications
        },
        "email": {
            "subject": "Welcome to Acme Corp",
            "html": "<h1>Welcome!</h1><p>Thanks for joining Acme Corp.</p>",
            "senderName": "Acme Team",
            "senderEmail": "hello@acme.com"
        }
    })

# Run the async function
asyncio.run(send_email())

use NotificationAPI\NotificationAPI;

// Initialize
$notificationapi = new NotificationAPI('YOUR_CLIENT_ID', 'YOUR_CLIENT_SECRET');

// Send email notification
$notificationapi->send([
    "type" => "welcome_email",
    "to" => [
        "id" => "user123",
        "email" => "user@example.com"  // Required for email notifications
    ],
    "email" => [
        "subject" => "Welcome to Acme Corp",
        "html" => "<h1>Welcome!</h1><p>Thanks for joining Acme Corp.</p>",
        "senderName" => "Acme Team",
        "senderEmail" => "hello@acme.com"
    ]
]);

package main

import (
    notificationapi "github.com/notificationapi-com/notificationapi-go-server-sdk"
)

func main() {
    // Initialize
    notificationapi.Init("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET", "https://api.notificationapi.com")

    // Prepare parameters
    parameters := make(map[string]interface{})
    parameters["firstName"] = "John"
    parameters["companyName"] = "Acme Corp"

    // Send email notification
    notificationapi.Send(
        notificationapi.SendRequest{
            Type: "welcome_email",
            To: notificationapi.User{
                Id:    "user123",
                Email: "user@example.com",  // Required for email notifications
            },
            Email: map[string]interface{}{
                "subject":    "Welcome to Acme Corp",
                "html":       "<h1>Welcome!</h1><p>Thanks for joining Acme Corp.</p>",
                "senderName": "Acme Team",
                "senderEmail":"hello@acme.com",
            },
        },
    )
}

using NotificationApi.Server;
using NotificationApi.Server.Models;

var notificationApi = new NotificationApiServer("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET");

notification = new SendNotificationData

Type = "welcome_email",
To = new User
{
  Id = "user123",
  Email = "user@example.com",
  Number = "+15005550006" // Replace with your phone number, use format [+][country code][area code][local number]
},
Email = new Dictionary<string, object>
{
    { "subject", "Welcome to Acme Corp" },
    { "html", "<h1>Welcome!</h1><p>Thanks for joining Acme Corp.</p>" },
    { "senderName", "Acme Team" },
    { "senderEmail", "hello@acme.com" }
}

it notificationApi.Send(notification);

package com.example;

import com.notificationapi.NotificationApi;
import com.notificationapi.model.*;

public class Example {
    public static void main(String[] args) {
        NotificationApi api = new NotificationApi(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET"
        );

        // Create user
        User user = new User("user123")
            .setEmail("user@example.com")
            .setNumber("+15005550006"); // Replace with your phone number, use format [+][country code][area code][local number];

        // Create and send notification request
        NotificationRequest request = new NotificationRequest("account_update_api", user)
            .setEmail(new EmailOptions()
                .setSubject("Welcome to Acme Corp")
                .setHtml("<h1>Welcome!</h1><p>Thanks for joining Acme Corp.</p>"),
                .setSenderName("Acme Team")
                .setSenderEmail("hello@acme.com")
            );

        System.out.println("Sending notification request...");
        String response = api.send(request);
        System.out.println("Response: " + response);
    }
}

# Initialize
notificationapi = NotificationAPI.new("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")

# Send email notification
notificationapi.send({
  type: 'welcome_email',
  to: {
    id: 'user123',
    email: 'user@example.com'  # Required for email notifications
  },
  email: {
    subject: 'Welcome to Acme Corp',
    html: '<h1>Welcome!</h1><p>Thanks for joining Acme Corp.</p>',
    senderName: 'Acme Team',
    senderEmail: 'hello@acme.com'
  }
})

You’re All Set!

🎉 Congrats! You’re now sending notifications!

If you’d like to send using templates configured in the Dashboard, check out our Templating guide and Backend Integration, or explore more advanced features below.

Advanced Email Features

Email with Attachments

You can send files as email attachments using either of two methods:

URL-based attachments: Use this method when your file is already hosted online and can be reached by NotificationAPI via a public or signed URL. Make sure the URL you provide is accessible at the time the email is sent - NotificationAPI needs to be able to fetch the file directly from that address. This is efficient for static or previously uploaded files.
Base64 content attachments: Use when your file is dynamically generated, privately held, or not accessible online. This lets you embed the file’s data directly in the request - no external hosting required.

Choose the approach that best fits how and where your file is stored or generated.

notificationapi.send({
  type: 'invoice_email',
  to: {
    id: 'user123',
    email: 'user@example.com'
  },
  email: {
    subject: 'Your Invoice INV-001',
    html: '<h1>Invoice</h1><p>Amount: $99.99</p>'
  },
  options: {
    email: {
      attachments: [
        {
          filename: 'invoice1.pdf',
          url: 'https://example.com/files/invoice.pdf'
        },
        {
          filename: 'invoice2.pdf',
          content: 'FILE_CONTENT_IN_BASE64',
          contentType: 'application/pdf'
        }
      ]
    }
  }
});

await notificationapi.send({
    "type": "invoice_email",
    "to": {
        "id": "user123",
        "email": "user@example.com"
    },
    "email": {
        "subject": "Your Invoice INV-001",
        "html": "<h1>Invoice</h1><p>Amount: $99.99</p>"
    },
    "options": {
        "email": {
            "attachments": [
                {
                    "filename": "invoice1.pdf",
                    "url": "https://example.com/files/invoice.pdf"
                },
                {
                    "filename": "invoice2.pdf",
                    "content": "FILE_CONTENT_IN_BASE64",
                    "contentType": "application/pdf"
                }
            ]
        }
    }
})

$notificationapi->send([
    "type" => "invoice_email",
    "to" => [
        "id" => "user123",
        "email" => "user@example.com"
    ],
    "email" => [
        "subject" => "Your Invoice INV-001",
        "html" => "<h1>Invoice</h1><p>Amount: $99.99</p>"
    ],
    "options" => [
        "email" => [
            "attachments" => [
                [
                    "filename" => "invoice1.pdf",
                    "url" => "https://example.com/files/invoice.pdf"
                ],
                [
                    "filename" => "invoice2.pdf",
                    "content" => "FILE_CONTENT_IN_BASE64",
                    "contentType" => "application/pdf"
                ]
            ]
        ]
    ]
]);

notificationapi.Send(
    notificationapi.SendRequest{
        Type: "invoice_email",
        To: notificationapi.User{
            Id:    "user123",
            Email: "user@example.com",
        },
        Email: map[string]interface{}{
            "subject": "Your Invoice INV-001",
            "html":    "<h1>Invoice</h1><p>Amount: $99.99</p>",
        },
        Options: map[string]interface{}{
            "email": map[string]interface{}{
                "attachments": []map[string]interface{}{
                    {
                        "filename": "invoice1.pdf",
                        "url":      "https://example.com/files/invoice.pdf",
                    },
                    {
                        "filename" => "invoice2.pdf",
                        "content" => "FILE_CONTENT_IN_BASE64",
                        "contentType" => "application/pdf"
                    },
                },
            },
        },
    },
)

var notification = new SendNotificationData
{
    Type = "invoice_email",
    To = new User
    {
        Id = "user123",
        Email = "user@example.com"
    },
    Email = new Dictionary<string, object>
    {
        { "subject", "Your Invoice INV-001" },
        { "html", "<h1>Invoice</h1><p>Amount: $99.99</p>" }
    },
    Options = new Dictionary<string, object>
    {
        { "email", new Dictionary<string, object>
            {
                { "attachments", new List<Dictionary<string, object>>
                    {
                        new Dictionary<string, object>
                        {
                            { "filename", "invoice1.pdf" },
                            { "url", "https://example.com/files/invoice.pdf" }
                        },
                        new Dictionary<string, object>
                        {
                            { "filename", "invoice2.pdf" },
                            { "content", "FILE_CONTENT_IN_BASE64",
                            { "contentType", "application/pdf" }
                        }
                        }
                    }
                }
            }
        }
    }
};

await notificationApi.Send(notification);

// Create user
User user = new User("user123")
    .setEmail("user@example.com");

// Create notification request
NotificationRequest request = new NotificationRequest("invoice_email", user)
    .setEmail(new EmailOptions()
        .setSubject("Your Invoice INV-001")
        .setHtml("<h1>Invoice</h1><p>Amount: $99.99</p>")
    )
    .setOptions(new HashMap<String, Object>() {{
        put("email", new HashMap<String, Object>() {{
            put("attachments", new ArrayList<Map<String, String>>() {{
                add(new HashMap<String, String>() {{
                    put("filename", "invoice1.pdf");
                    put("url", "https://example.com/files/invoice.pdf");
                }});
                add(new HashMap<String, String>() {{
                    put("filename", "invoice2.pdf");
                    put("content", "FILE_CONTENT_IN_BASE64");
                    put("contentType", "application/pdf");
                }});
            }});
        }});
    }});

String response = api.send(request);

notificationapi.send({
  type: 'invoice_email',
  to: {
    id: 'user123',
    email: 'user@example.com'
  },
  email: {
    subject: 'Your Invoice INV-001',
    html: '<h1>Invoice</h1><p>Amount: $99.99</p>'
  },
  options: {
    email: {
      attachments: [
        {
          filename: 'invoice1.pdf',
          url: 'https://example.com/files/invoice.pdf'
        },
        {
          filename: 'invoice2.pdf',
          content: 'FILE_CONTENT_IN_BASE64',
          contentType: 'application/pdf'
        }
      ]
    }
  }
})

INFO

Use only the raw base64 string (no data: prefix). Set contentType when it cannot be inferred from the filename.

CC and BCC Recipients

Send copies of your email to additional recipients:

notificationapi.send({
  type: 'team_update',
  to: {
    id: 'primary-user',
    email: 'primary@example.com'
  },
  email: {
    subject: 'Team Update: Website Redesign',
    html: '<p>Status Update: New features are now available!</p>'
  },
  options: {
    email: {
      ccAddresses: ['manager@example.com', 'team-lead@example.com'],
      bccAddresses: ['compliance@example.com']
    }
  }
});

await notificationapi.send({
    "type": "team_update",
    "to": {
        "id": "primary-user",
        "email": "primary@example.com"
    },
    "email": {
        "subject": "Team Update: Website Redesign",
        "html": "<p>Status Update: New features are now available!</p>"
    },
    "options": {
        "email": {
            "ccAddresses": ["manager@example.com", "team-lead@example.com"],
            "bccAddresses": ["compliance@example.com"]
        }
    }
})

$notificationapi->send([
    "type" => "team_update",
    "to" => [
        "id" => "primary-user",
        "email" => "primary@example.com"
    ],
    "email" => [
        "subject" => "Team Update: Website Redesign",
        "html" => "<p>Status Update: New features are now available!</p>"
    ],
    "options" => [
        "email" => [
            "ccAddresses" => ["manager@example.com", "team-lead@example.com"],
            "bccAddresses" => ["compliance@example.com"]
        ]
    ]
]);

notificationapi.Send(
    notificationapi.SendRequest{
        Type: "team_update",
        To: notificationapi.User{
            Id:    "primary-user",
            Email: "primary@example.com",
        },
        Email: map[string]interface{}{
            "subject": "Team Update: Website Redesign",
            "html":    "<p>Status Update: New features are now available!</p>",
        },
        Options: map[string]interface{}{
            "email": map[string]interface{}{
                "ccAddresses":  []string{"manager@example.com", "team-lead@example.com"},
                "bccAddresses": []string{"compliance@example.com"},
            },
        },
    },
)

var notification = new SendNotificationData
{
    Type = "team_update",
    To = new User
    {
        Id = "primary-user",
        Email = "primary@example.com"
    },
    Email = new Dictionary<string, object>
    {
        { "subject", "Team Update: Website Redesign" },
        { "html", "<p>Status Update: New features are now available!</p>" }
    },
    Options = new Dictionary<string, object>
    {
        { "email", new Dictionary<string, object>
            {
                { "ccAddresses", new List<string> { "manager@example.com", "team-lead@example.com" } },
                { "bccAddresses", new List<string> { "compliance@example.com" } }
            }
        }
    }
};

await notificationApi.Send(notification);

// Create user
User user = new User("primary-user")
    .setEmail("primary@example.com");

// Create notification request
NotificationRequest request = new NotificationRequest("team_update", user)
    .setEmail(new EmailOptions()
        .setSubject("Team Update: Website Redesign")
        .setHtml("<p>Status Update: New features are now available!</p>")
    )
    .setOptions(new HashMap<String, Object>() {{
        put("email", new HashMap<String, Object>() {{
            put("ccAddresses", Arrays.asList("manager@example.com", "team-lead@example.com"));
            put("bccAddresses", Arrays.asList("compliance@example.com"));
        }});
    }});

String response = api.send(request);

notificationapi.send({
  type: 'team_update',
  to: {
    id: 'primary-user',
    email: 'primary@example.com'
  },
  email: {
    subject: 'Team Update: Website Redesign',
    html: '<p>Status Update: New features are now available!</p>'
  },
  options: {
    email: {
      ccAddresses: ['manager@example.com', 'team-lead@example.com'],
      bccAddresses: ['compliance@example.com']
    }
  }
})

Reply-To Addresses

Set custom reply-to addresses for two-way email communication:

notificationapi.send({
  type: 'support_ticket',
  to: {
    id: 'customer123',
    email: 'customer@example.com'
  },
  email: {
    subject: 'Support Ticket TKT-456',
    html: '<p>Issue: Login problems</p>'
  },
  options: {
    email: {
      replyToAddresses: ['support@yourcompany.com']
    }
  }
});

await notificationapi.send({
    "type": "support_ticket",
    "to": {
        "id": "customer123",
        "email": "customer@example.com"
    },
    "email": {
        "subject": "Support Ticket TKT-456",
        "html": "<p>Issue: Login problems</p>"
    },
    "options": {
        "email": {
            "replyToAddresses": ["support@yourcompany.com"]
        }
    }
})

$notificationapi->send([
    "type" => "support_ticket",
    "to" => [
        "id" => "customer123",
        "email" => "customer@example.com"
    ],
    "email" => [
        "subject" => "Support Ticket TKT-456",
        "html" => "<p>Issue: Login problems</p>"
    ],
    "options" => [
        "email" => [
            "replyToAddresses" => ["support@yourcompany.com"]
        ]
    ]
]);

notificationapi.Send(
    notificationapi.SendRequest{
        Type: "support_ticket",
        To: notificationapi.User{
            Id:    "customer123",
            Email: "customer@example.com",
        },
        Email: map[string]interface{}{
            "subject": "Support Ticket TKT-456",
            "html":    "<p>Issue: Login problems</p>",
        },
        Options: map[string]interface{}{
            "email": map[string]interface{}{
                "replyToAddresses": []string{"support@yourcompany.com"},
            },
        },
    },
)

var notification = new SendNotificationData
{
    Type = "support_ticket",
    To = new User
    {
        Id = "customer123",
        Email = "customer@example.com"
    },
    Email = new Dictionary<string, object>
    {
        { "subject", "Support Ticket TKT-456" },
        { "html", "<p>Issue: Login problems</p>" }
    },
    Options = new Dictionary<string, object>
    {
        { "email", new Dictionary<string, object>
            {
                { "replyToAddresses", new List<string> { "support@yourcompany.com" } }
            }
        }
    }
};

await notificationApi.Send(notification);

// Create user
User user = new User("customer123")
    .setEmail("customer@example.com");

// Create notification request
NotificationRequest request = new NotificationRequest("support_ticket", user)
    .setEmail(new EmailOptions()
        .setSubject("Support Ticket TKT-456")
        .setHtml("<p>Issue: Login problems</p>")
    )
    .setOptions(new HashMap<String, Object>() {{
        put("email", new HashMap<String, Object>() {{
            put("replyToAddresses", Arrays.asList("support@yourcompany.com"));
        }});
    }});

String response = api.send(request);

notificationapi.send({
  type: 'support_ticket',
  to: {
    id: 'customer123',
    email: 'customer@example.com'
  },
  email: {
    subject: 'Support Ticket TKT-456',
    html: '<p>Issue: Login problems</p>'
  },
  options: {
    email: {
      replyToAddresses: ['support@yourcompany.com']
    }
  }
})

Custom From Address

Set a custom from address and sender name for your emails:

notificationapi.send({
  type: 'marketing_newsletter',
  to: {
    id: 'subscriber123',
    email: 'subscriber@example.com'
  },
  email: {
    subject: 'Your Company Newsletter',
    html: '<h1>New features are now available!</h1>'
  },
  options: {
    email: {
      fromAddress: 'newsletter@yourcompany.com',
      fromName: 'Your Company Newsletter'
    }
  }
});

await notificationapi.send({
    "type": "marketing_newsletter",
    "to": {
        "id": "subscriber123",
        "email": "subscriber@example.com"
    },
    "email": {
        "subject": "Your Company Newsletter",
        "html": "<h1>New features are now available!</h1>"
    },
    "options": {
        "email": {
            "fromAddress": "newsletter@yourcompany.com",
            "fromName": "Your Company Newsletter"
        }
    }
})

$notificationapi->send([
    "type" => "marketing_newsletter",
    "to" => [
        "id" => "subscriber123",
        "email" => "subscriber@example.com"
    ],
    "email" => [
        "subject" => "Your Company Newsletter",
        "html" => "<h1>New features are now available!</h1>"
    ],
    "options" => [
        "email" => [
            "fromAddress" => "newsletter@yourcompany.com",
            "fromName" => "Your Company Newsletter"
        ]
    ]
]);

notificationapi.Send(
    notificationapi.SendRequest{
        Type: "marketing_newsletter",
        To: notificationapi.User{
            Id:    "subscriber123",
            Email: "subscriber@example.com",
        },
        Email: map[string]interface{}{
            "subject": "Your Company Newsletter",
            "html":    "<h1>New features are now available!</h1>",
        },
        Options: map[string]interface{}{
            "email": map[string]interface{}{
                "fromAddress": "newsletter@yourcompany.com",
                "fromName":    "Your Company Newsletter",
            },
        },
    },
)

var notification = new SendNotificationData
{
    Type = "marketing_newsletter",
    To = new User
    {
        Id = "subscriber123",
        Email = "subscriber@example.com"
    },
    Email = new Dictionary<string, object>
    {
        { "subject", "Your Company Newsletter" },
        { "html", "<h1>New features are now available!</h1>" }
    },
    Options = new Dictionary<string, object>
    {
        { "email", new Dictionary<string, object>
            {
                { "fromAddress", "newsletter@yourcompany.com" },
                { "fromName", "Your Company Newsletter" }
            }
        }
    }
};

await notificationApi.Send(notification);

// Create user
User user = new User("subscriber123")
    .setEmail("subscriber@example.com");

// Create notification request
NotificationRequest request = new NotificationRequest("marketing_newsletter", user)
    .setEmail(new EmailOptions()
        .setSubject("Your Company Newsletter")
        .setHtml("<h1>New features are now available!</h1>")
    )
    .setOptions(new HashMap<String, Object>() {{
        put("email", new HashMap<String, Object>() {{
            put("fromAddress", "newsletter@yourcompany.com");
            put("fromName", "Your Company Newsletter");
        }});
    }});

String response = api.send(request);

notificationapi.send({
  type: 'marketing_newsletter',
  to: {
    id: 'subscriber123',
    email: 'subscriber@example.com'
  },
  email: {
    subject: 'Your Company Newsletter',
    html: '<h1>New features are now available!</h1>'
  },
  options: {
    email: {
      fromAddress: 'newsletter@yourcompany.com',
      fromName: 'Your Company Newsletter'
    }
  }
})

INFO

To use a custom fromAddress from your domain, you’ll need to verify your domain first. See your NotificationAPI dashboard under Settings -> Domain Verification for setup instructions. We strongly recommend you to verify your domain before sending emails from production.

Important Email Features

NotificationAPI provides comprehensive email functionality with advanced features:

High delivery through SPF, DKIM and DMARC - see your dashboard for domain verification setup
Compliant with Google’s and Yahoo’s email sender policies and best practices for high deliverability
Merge tags (injecting dynamic values into the email content) - see docs
Pre-built Unsubscribe Link and Web Page - see docs. To capture unsubscribe events in your backend, see Events Webhook.
Reply-to addresses for two-way email communication via options.email.replyToAddresses - see docs
File attachments via options.email.attachments - see docs
CC and BCC recipients via options.email.ccAddresses and options.email.bccAddresses - see docs

TIP

You DON’T need another 3rd-party email service like SendGrid or SES. Through our partnerships, We allocate and manage any required email infrastructure, even dedicated IPs, for you.

Google and Yahoo Bulk Sender Requirements

NotificationAPI automatically handles compliance with Google and Yahoo bulk sender requirements (read more on our blog):

Authentication: SPF, DKIM, DMARC configured automatically
Unsubscribe: One-click unsubscribe headers and links included per RFC 2369 and RFC 8058
Compliance: All requirements handled automatically in your account setup

Tracking and Analytics

NotificationAPI automatically tracks:

Delivery: Email successfully delivered to mail server
Bounces: Failed delivery attempts
Complaints: Users marking emails as spam
Opens: Users opening the email
Clicks: Users clicking on links in the email

NotificationAPI uses a custom domain for all tracking links included in your emails. This means that any tracking links in your email are instrumented with a custom domain, allowing us to accurately track when your email is opened and when a recipient clicks on a link.

If you want to set up a webhook for these events (such as opens and clicks), see our Events Webhook documentation for setup instructions.

You can also receive an event when a user unsubscribes from an email via our Events Webhook (EMAIL_UNSUBSCRIBE).

View all analytics in your dashboard under Logs and Insights.

Frequently Asked Questions

Do I need to configure SMTP to send emails?

No! NotificationAPI handles all SMTP configuration and email infrastructure for you automatically. You don’t need to:

Set up or configure SMTP servers
Manage SMTP credentials
Use third-party email services like SendGrid, Amazon SES, or Mailgun
Deal with SMTP ports, authentication, or connection settings

Simply use our API to send emails, and we’ll handle all the underlying SMTP infrastructure, authentication (SPF, DKIM, DMARC), and delivery. For production use, you only need to verify your domain through DNS records - see Domain Verification for details.

Can I send emails without verifying my domain?

Yes! For testing and development, you can send emails immediately without any domain verification. Emails will be sent from our domain @notificationapi.com with no configuration required.

For production use, we strongly recommend verifying your domain so that:

Emails come from your own domain (e.g., hello@yourcompany.com)
You have better deliverability and inbox placement
Your brand is represented in the sender address
You comply with email authentication best practices (SPF, DKIM, DMARC)

To verify your domain, go to Dashboard → Settings → Domain Verification and follow the step-by-step instructions to add DNS records. See our Domain Verification guide for detailed help.

Does NotificationAPI support using custom SMTP?

Not currently. SMTP support is on our product roadmap. If this is important for your use case, please reach out via our live chat or Slack to discuss timelines and when this could be integrated.

Need more help?

If you need help, reach out through our live chat or Slack community.