Mailtrap - Comify

The Mailtrap provider enables you to deliver professional transactional emails to your customers through the Comify Platform. With a single API integration, you can create seamless multi-channel communication experiences.

Getting Started

Implementing the Mailtrap email provider requires three primary steps: creating a Mailtrap account, generating a Mailtrap API token, and configuring the Mailtrap integration within your Comify platform.

Creating a Mailtrap Account

Follow these steps to set up your Mailtrap account:

Visit Mailtrap’s official website and select “Sign Up”.
Enter all required information to create your account or sign up with your Google, GitHub, or Microsoft account.
Complete any additional verification process if prompted.
Once verification is complete, you’ll be directed to your Mailtrap dashboard.

Creating a Sending Domain

Before generating an API token, you’ll need to set up and verify a sending domain:

In your Mailtrap dashboard, navigate to Email Sending > Sending Domains.
Click “Add Domain” and enter your domain name.
Follow the instructions to add and verify the required DNS records.
Wait for the domain verification to complete.

Creating a Mailtrap API Token

Follow these steps to access and secure your Mailtrap API token:

In your Mailtrap dashboard, navigate to Settings in the left sidebar, then select API Tokens.
To add a new token, click the “Add Token” button in the upper right corner.
Enter a descriptive name for your token (e.g., “Comify Integration”) for easy identification.
Assign appropriate permissions by checking the boxes in the corresponding access level columns. Make sure you have admin permissions on the domains you want to use.
Click the “Save” button and your new token will appear under the API Tokens main menu.
Alternatively, you can use the auto-created token per domain. When you create a domain, a token is automatically created and named based on the formula: [domain name] + [token] + [token ID].
To find the token for a specific domain, go to Email Sending > Sending Domains, select your domain, click the “Integration” tab, and choose API or SMTP integration to view your token.

Creating a Comify API Key

Before configuring the Mailtrap integration, you’ll need to generate a Comify API key for authentication:

Access your Comify account dashboard.
Navigate to the API Keys management section at https://cloud.comify.io/settings/api-keys.
Select “Generate API Key” if not already generated.
Provide a clear, descriptive name for your key (e.g., “Mailtrap Integration”) to facilitate future management.
Copy and store this API key in a secure location. You’ll use this key in your application code to authenticate requests to the Comify platform.

Configuring Mailtrap Integration in Comify

To establish the connection between Comify and Mailtrap:

Sign in to your Comify platform dashboard.
Navigate to Integration Store > Add Integration > E-mail.
From the available email service providers, select Mailtrap.
Enter the Mailtrap API token you generated earlier.
Configure any additional provider-specific settings according to your requirements.
Click Save to finalize the integration.

Creating Email Templates

After successfully configuring the Mailtrap integration, you can design email templates directly within the Comify platform:

Navigate to the Manage Templates section in your Comify dashboard.
Select the Email tab from the available channel options.
Click Create Template to begin the design process.
Choose from multiple template creation methods based on your preference and skill level:
- AI-Assisted Design: Utilize the AI Writer feature in the Email Editor section for automated content generation.
- Manual HTML Editing: Select Switch to HTML in the Email Editor for direct code editing.
- Import Existing Templates: Use the Chrome extension to copy HTML from existing templates for reuse in Comify.

Sending Email Templates

Implement the following code examples in your application to trigger email template delivery:

const { Comify } = require('comify-node')

const comm = new Comify('COMIFY_API_KEY')

comm.triggerComm('email_template_name',{ 
  "order_id" : "123455",
  "billing" : {
    "customerEmail" : "contact@comify.io",
    "customerName" : "Comify"
  }
}, 'email')

const fetch = require('node-fetch');

const apiKey = 'YOUR_COMIFY_API_KEY';
const url = 'https://commify.transify.tech/v1/comm';

const payload = {
  name: 'email_template_name',
  payload: { 
    order_id: '123455',
    billing: {
      customerEmail: 'contact@comify.io',
      customerName: 'Comify'
    }
  },
  type: 'email'
};

fetch(url, {
  method: 'POST',
  headers: {
    'Authorization': `ApiKey ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

import requests

api_key = 'YOUR_COMIFY_API_KEY'
url = 'https://commify.transify.tech/v1/comm'

headers = {
    'Authorization': f'ApiKey {api_key}',
    'Content-Type': 'application/json'
}

payload = {
    'name': 'email_template_name',
    'payload': {
        'order_id': '123455',
        'billing': {
            'customerEmail': 'contact@comify.io',
            'customerName': 'Comify'
        }
    },
    'type': 'email'
}

response = requests.post(url, headers=headers, json=payload)
print(response.json())

require 'net/http'
require 'uri'
require 'json'

api_key = 'YOUR_COMIFY_API_KEY'
url = URI.parse('https://commify.transify.tech/v1/comm')

payload = {
  name: 'email_template_name',
  payload: {
    order_id: '123455',
    billing: {
      customerEmail: 'contact@comify.io',
      customerName: 'Comify'
    }
  },
  type: 'email'
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url.request_uri)
request['Authorization'] = "ApiKey #{api_key}"
request['Content-Type'] = 'application/json'
request.body = payload.to_json

response = http.request(request)
puts response.body

<?php
$api_key = 'YOUR_COMIFY_API_KEY';
$url = 'https://commify.transify.tech/v1/comm';

$payload = [
    'name' => 'email_template_name',
    'payload' => [
        'order_id' => '123455',
        'billing' => [
            'customerEmail' => 'contact@comify.io',
            'customerName' => 'Comify'
        ]
    ],
    'type' => 'email'
];

$ch = curl_init($url);

curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Authorization: ApiKey ' . $api_key,
    'Content-Type: application/json'
]);

$response = curl_exec($ch);
$err = curl_error($ch);

curl_close($ch);

if ($err) {
    echo "cURL Error: " . $err;
} else {
    echo $response;
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    apiKey := "YOUR_COMIFY_API_KEY"
    url := "https://commify.transify.tech/v1/comm"

    // Create the payload structure
    type Billing struct {
        CustomerEmail string `json:"customerEmail"`
        CustomerName  string `json:"customerName"`
    }

    type PayloadData struct {
        OrderID string  `json:"order_id"`
        Billing Billing `json:"billing"`
    }

    type RequestPayload struct {
        Name    string      `json:"name"`
        Payload PayloadData `json:"payload"`
        Type    string      `json:"type"`
    }

    data := RequestPayload{
        Name: "email_template_name",
        Payload: PayloadData{
            OrderID: "123455",
            Billing: Billing{
                CustomerEmail: "contact@comify.io",
                CustomerName:  "Comify",
            },
        },
        Type: "email",
    }

    payloadBytes, err := json.Marshal(data)
    if err != nil {
        fmt.Println("Error marshalling JSON:", err)
        return
    }

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("Authorization", "ApiKey "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error sending request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }

    fmt.Println("Response:", string(body))
}

curl -X POST 'https://commify.transify.tech/v1/comm' \
  -H 'Authorization: ApiKey YOUR_COMIFY_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "email_template_name",
    "payload": { 
      "order_id": "123455",
      "billing": {
        "customerEmail": "contact@comify.io",
        "customerName": "Comify"
      }
    },
    "type": "email"
  }'

Upon successful API request processing, you will receive a response containing a unique requestId and confirmation message:

{
  "requestId": "016e9d9c-ea29-455c-bf2e-a703e96482fb",
  "message": "your request has been submitted"
}

Important: The API may return a success response even when there are underlying issues with your request. For comprehensive delivery monitoring and troubleshooting, we recommend reviewing the complete request logs in the Activity Feed dashboard.

Getting Started

Channels

Documentation Index

​Getting Started

​Creating a Mailtrap Account

​Creating a Sending Domain

​Creating a Mailtrap API Token

​Creating a Comify API Key

​Configuring Mailtrap Integration in Comify

​Creating Email Templates

​Sending Email Templates

Getting Started

Creating a Mailtrap Account

Creating a Sending Domain

Creating a Mailtrap API Token

Creating a Comify API Key

Configuring Mailtrap Integration in Comify

Creating Email Templates

Sending Email Templates