> ## Documentation Index
> Fetch the complete documentation index at: https://docs.comify.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Mandrill

> Learn how to send emails via Mandrill using Comify.

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

## Creating a Mandrill Account

Follow these steps to set up your Mandrill account:

1. If you already have a Mailchimp account with a Standard plan or higher, you can enable Mailchimp Transactional (formerly Mandrill) from the [Monthly plans or credits page](https://us1.admin.mailchimp.com/account/billing-plan/).
2. If you don't have a Mailchimp account, visit [Mailchimp's official website](https://mailchimp.com/) and select "Sign Up Free".
3. Enter all required information to create your account.
4. Complete the security verification process for both your email address and phone number.
5. Once verification is complete, upgrade to a Standard plan or higher to access Mailchimp Transactional features.
6. Navigate to the Transactional Email section in your Mailchimp dashboard to set up your sending domain.

## Creating a Mandrill API Key

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

1. Navigate to the [Settings](https://mandrillapp.com/settings) of your Mailchimp Transactional account.
2. Look for the API Keys section and click "Create New Key".
3. Assign a descriptive name to your key (e.g., "Comify Integration") for easy identification.
4. Copy the generated key immediately and store it in a secure location. Important: For security purposes, you won't be able to see or copy the key once you finish generating it.
5. Remember that your Mandrill API key provides full account access, so keep it secure, as you would a password.

## Creating a Comify API Key

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

1. Access your Comify account dashboard.
2. Navigate to the API Keys management section at [https://cloud.comify.io/settings/api-keys](https://cloud.comify.io/settings/api-keys).
3. Select "Generate API Key" if not already generated.
4. Provide a clear, descriptive name for your key (e.g., "Mandrill Integration") to facilitate future management.
5. 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 Mandrill Integration in Comify

To establish the connection between Comify and Mandrill:

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

![Mandrill Comify Integration](https://ik.imagekit.io/flaberry/transify-waba/comify-docs/channels/mandrill-comify-integration.png)

## Creating Email Templates

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

1. Navigate to the [Manage Templates](https://cloud.comify.io/templates/manage) section in your Comify dashboard.
2. Select the `Email` tab from the available channel options.
3. Click `Create Template` to begin the design process.
4. 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:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={null}
    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')
    ```
  </Tab>

  <Tab title="Node.js (Fetch)">
    ```javascript theme={null}
    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));
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={null}
    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())
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby theme={null}
    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
    ```
  </Tab>

  <Tab title="PHP">
    ```php theme={null}
    <?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);

    $result = json_decode($response, true);
    print_r($result);
    ?>
    ```
  </Tab>

  <Tab title="Go">
    ```go theme={null}
    package main

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

    type BillingInfo struct {
        CustomerEmail string `json:"customerEmail"`
        CustomerName  string `json:"customerName"`
    }

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

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

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

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

        jsonData, err := json.Marshal(payload)
        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("Response:", string(body))
    }
    ```
  </Tab>

  <Tab title="Curl">
    ```bash theme={null}
    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"
        }'
    ```
  </Tab>
</Tabs>

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

```json theme={null}
{
  "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](https://cloud.comify.io/monitor/activity) dashboard.