SendGrid - Comify

The SendGrid 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 SendGrid email provider requires three primary steps: creating a SendGrid account, generating a SendGrid API key, and configuring the SendGrid integration within your Comify platform.

Creating a SendGrid Account

Follow these steps to set up your SendGrid account:

Visit SendGrid’s official website and select “Start for Free”.
Enter all required information to create your account. Note that this user will serve as the primary SendGrid account administrator.
Complete the security verification process for both your email address and phone number.
Store the provided Recovery Code in a secure location for account recovery purposes.
Once verification is complete, select “Create new account” to proceed with your initial login and finalize your account setup.
Use the SendGrid setup wizard to configure your sender identities. Access this guide at app.sendgrid.com/guide.

Creating a SendGrid API Key

Follow these steps to generate and secure your SendGrid API key:

In your SendGrid dashboard, navigate to Settings in the left sidebar, then select API Keys.
Click the Create API Key button.
Assign a descriptive name to your key (e.g., “Comify Integration”) for easy identification.
Select the appropriate access level. For enhanced security, we recommend using Restricted Access with only the minimum permissions necessary.
When using Restricted Access, carefully select only the specific permissions required for email delivery functionality.
Click Create & View to generate your key.
Immediately copy and securely store your API key. Important: For security purposes, SendGrid displays this key only once.

Creating a Comify API Key

Before configuring the SendGrid 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., “SendGrid 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 SendGrid Integration in Comify

To establish the connection between Comify and SendGrid:

Sign in to your Comify platform dashboard.
Navigate to Integration Store > Add Integration > E-mail.
From the available email service providers, select SendGrid.
Enter the SendGrid API key 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 SendGrid 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 { 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);
curl_close($ch);

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"
    
    type Billing struct {
        CustomerEmail string `json:"customerEmail"`
        CustomerName  string `json:"customerName"`
    }
    
    type PayloadData struct {
        OrderID string  `json:"order_id"`
        Billing Billing `json:"billing"`
    }
    
    type RequestBody struct {
        Name    string      `json:"name"`
        Payload PayloadData `json:"payload"`
        Type    string      `json:"type"`
    }
    
    data := RequestBody{
        Name: "email_template_name",
        Payload: PayloadData{
            OrderID: "123455",
            Billing: Billing{
                CustomerEmail: "contact@comify.io",
                CustomerName:  "Comify",
            },
        },
        Type: "email",
    }
    
    jsonData, err := json.Marshal(data)
    if err != nil {
        fmt.Println("Error marshalling JSON:", err)
        return
    }
    
    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    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(string(body))
}

import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class ComifySendEmail {
    public static void main(String[] args) {
        try {
            String apiKey = "YOUR_COMIFY_API_KEY";
            URL url = new URL("https://commify.transify.tech/v1/comm");
            
            String jsonPayload = "{"
                + "\"name\": \"email_template_name\","
                + "\"payload\": {"
                + "    \"order_id\": \"123455\","
                + "    \"billing\": {"
                + "        \"customerEmail\": \"contact@comify.io\","
                + "        \"customerName\": \"Comify\""
                + "    }"
                + "},"
                + "\"type\": \"email\""
                + "}";
            
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Authorization", "ApiKey " + apiKey);
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setDoOutput(true);
            
            try (OutputStream os = connection.getOutputStream()) {
                byte[] input = jsonPayload.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }
            
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            
            try (Scanner scanner = new Scanner(connection.getInputStream(), StandardCharsets.UTF_8.name())) {
                String responseBody = scanner.useDelimiter("\\A").next();
                System.out.println(responseBody);
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

​Getting Started

​Creating a SendGrid Account

​Creating a SendGrid API Key

​Creating a Comify API Key

​Configuring SendGrid Integration in Comify

​Creating Email Templates

​Sending Email Templates

Getting Started

Creating a SendGrid Account

Creating a SendGrid API Key

Creating a Comify API Key

Configuring SendGrid Integration in Comify

Creating Email Templates

Sending Email Templates