Changelog

API Send

Endpoint:

https://api.kasplo.com/v1/send-email

Headers: 


Unset      
Authorization: Bearer 
Content-Type: application/json

Request Body (example): 

{
    "email": {
        "from": "sender@yourdomain.com",
        "fromName": "sender name",
        "replyTo": [
            "abcd@yourdomain.com"
        ],
        "subject": "Custom subject line",
        "text": "This is a Multipart email",
        "html": "<h1>Test Email</h1>",
        "amp": "<AMP_TEMPLATE_HTML_CODE>",
        "recipients": {
            "to": [
                {
                    "email": "recipient@example.com"
                }
            ],
            "cc": [],
            "bcc": []
        },
        "attachments": []
    },
    "metadata": {
        "messageId": "custom-id-value"
    }
}

Note: For AMP email support

  1. AMP email sending requires prior approval from ISPs like Gmail and Yahoo.
  2. Approval is tied to the sender name. You must apply using the exact “From” name you intend to use in your campaigns.
  3. Kasplo allows you to send AMP emails once your sender identity is approved.
  4. All AMP form/data submission endpoints must be client-hosted and follow AMP security requirements.

Response (example): 


Unset
  {
  "statusCode": 1000,
  "status": "SUCCESS",
  "message": "NA",
 }

Event Header (SMTP request): X-Kasplo-Click-Tracking-ID

Kasplo allows you to set a custom identifier for click events, which will be reflected in webhook payloads under click tracking.

Header Name:


X-Kasplo-Click-Tracking-ID

Usage Example: 


X-Kasplo-Click-Tracking-ID: 1234

Valid Values:

  • A string composed of ASCII characters (decimal 32 to 126). No control characters or tabs.
  • Maximum length: 300 characters.
  • Recommended: Keep the value short to minimize payload size and overhead.

Bounce Events

  • bounce_all: Includes all bounce events (informational only).

  • bounce_bad_address: Indicates addresses that should be deactivated.

  • Bounce Types:

    • h: Hard

    • s: Soft

    • o: Other

Delivery Attempt

Possible results:

  • success

     

  • failure

     

  • failure_toolong

     

  • deferral

     

  • connmaxout

Unsubscribe

Kasplo provides two ways to manage unsubscribe links in your email templates, depending on whether you want unsubscribe clicks to be tracked or left untouched.

Add [[unsub]] placeholder in your email template to enable tracking.

Non-tracked unsubscribe link

If you wish to use a custom unsubscribe URL that should not be replaced or tracked by Kasplo, include the following literal token in the URL:

##UNSUB-LINK##

Advanced Features

  • Performance & Throttling: Configurable per plan to support enterprise-level throughput.

     

  • Suppression Management: Automatic for bounces, complaints, unsubscribes; manual via portal.

     

  • IP Pools:

     

    • Shared IPs (default)

       

    • Dedicated IPs (available at additional cost)

       

  • AMP for Email Support: Kasplo supports AMP emails. Form/data endpoints must be client-hosted.

     

  • Forwarding & Incoming Emails: Store and track replies inside Kasplo.

     

  • Attachments: Supports PDF, DOCX, PNG, JPG, CSV, ZIP. Size limits depend on the plan.

Email Intelligence (EI) Add-on (Optional)

  • Inbox Tracker: Monitor inbox placement.

  • Reputation Manager: Track domain/IP reputation trends.

  • Blacklist Monitoring: Get alerts on blacklistings.

  • Compliance Insights: Identify spam traps and avoid compliance issues.

  • EI Vault: Explore competitor email strategies and templates.

SDKs

SDKs will be available for the following languages (sample usage coming soon):

  • Python / Ruby
import smtplib
import random
import threading
import time
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# Configuration
concurrent_requests = 1
total_requests = 1

email_list = ["<email>"]

smtp_host = 'smtp.kasplo.com'
smtp_port = 587
smtp_username = '<user-name>'
smtp_password = '<password>'

arr = []
total_time = 0
lock = threading.Lock()

def get_random_email():
    return random.choice(email_list)

def send_email():
    global total_time
    start_time = time.time()
    try:
        receiver_email = get_random_email()

        # Create email
        message = MIMEMultipart("alternative")
        message["Subject"] = "Testing on April15 1.0"
        message["From"] = "Kasplo <info@trans.kasplo.in>"
        message["To"] = receiver_email

        text = "Testing text content"
        html = """\
        <html>
          <body>
            <b><i>This is a test email for verifying our email standards.</i></b>
            <a href="https://www.google.com">Click here</a>
          </body>
        </html>
        """

        part1 = MIMEText(text, "plain")
        part2 = MIMEText(html, "html")

        message.attach(part1)
        message.attach(part2)

        # Connect and send email
        with smtplib.SMTP(smtp_host, smtp_port) as server:
            server.login(smtp_username, smtp_password)
            server.sendmail(smtp_username, receiver_email, message.as_string())

        elapsed = time.time() - start_time
        with lock:
            arr.append(elapsed)
            total_time += elapsed
        print(f"Email sent to {receiver_email} in {elapsed:.2f}s")
    except Exception as e:
        print("Email sending failed:", e)

def run_batch():
    threads = []
    for _ in range(concurrent_requests):
        t = threading.Thread(target=send_email)
        t.start()
        threads.append(t)
    for t in threads:
        t.join()

if __name__ == "__main__":
    time.sleep(1)
    for i in range(total_requests // concurrent_requests):
        print(f"Batch {i + 1}")
        run_batch()
    if arr:
        print(f"Average time taken: {sum(arr) / len(arr):.2f}s")
  • PHP
<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'vendor/autoload.php';

$concurrentRequests = 1;
$totalRequests = 1;
$emails = ["<email>"]; // Replace with real email addresses

$smtpHost = 'smtp.kasplo.com';
$smtpPort = 587;
$smtpUsername = '<user-name>';
$smtpPassword = '<password>';

$arr = [];
$totalTime = 0;

function getRandomEmail($emails) {
    return $emails[array_rand($emails)];
}

function sendEmail($smtpHost, $smtpPort, $smtpUsername, $smtpPassword, $emails) {
    $start = microtime(true);
    
    $mail = new PHPMailer(true);
    try {
        // SMTP settings
        $mail->isSMTP();
        $mail->Host = $smtpHost;
        $mail->SMTPAuth = true;
        $mail->Username = $smtpUsername;
        $mail->Password = $smtpPassword;
        $mail->Port = $smtpPort;

        // Email content
        $to = getRandomEmail($emails);
        $mail->setFrom('info@trans.kasplo.in', 'Kasplo');
        $mail->addAddress($to);
        $mail->Subject = 'Testing on April15 php1.0';
        $mail->Body    = '<b><i>This is a test email for verifying our email standards.</i></b>
                          <a href="https://www.google.com">Click here</a>';
        $mail->isHTML(true);

        $mail->send();
        echo "Email sent to $to\n";
    } catch (Exception $e) {
        echo "Email failed: {$mail->ErrorInfo}\n";
    }

    return microtime(true) - $start;
}

// Run email batches
for ($i = 0; $i < $totalRequests / $concurrentRequests; $i++) {
    echo "Batch " . ($i + 1) . "\n";
    for ($j = 0; $j < $concurrentRequests; $j++) {
        $timeTaken = sendEmail($smtpHost, $smtpPort, $smtpUsername, $smtpPassword, $emails);
        $arr[] = $timeTaken;
        $totalTime += $timeTaken;
    }
}

$avgTime = $totalTime / count($arr);
echo "Average time taken: $avgTime seconds\n";
  • GoLang
    
package main
import (
    "fmt"
    "log"
    "strings"
    "github.com/emersion/go-sasl"
    "github.com/emersion/go-smtp"
    "gopkg.in/gomail.v2"
)
func main() {
    email := "avinash@kasplo.com"
    m := gomail.NewMessage()
    from := "info@trans.kasplo.in"
    m.SetHeader("From", from)
    m.SetHeader("To", email)
    m.SetHeader("Subject", "Hello testing mail from Kasplo!")
    htmlContent := `
    <!DOCTYPE html>
    <p>Hello, this is a test html body <a href=\"https://www.google.com\">Click here</a></p>
    `
    m.SetBody("text/html", htmlContent)
    smtpHost := "smtp.kasplo.com"
    smtpPort := "587"
    smtpUser := "<user-name>"
    smtpPassword := "<password>"
    addr := fmt.Sprintf("%s:%s", smtpHost, smtpPort)
    // Connect with TLS directly
    client, err := smtp.Dial(addr)
    if err != nil {
        log.Fatalf("Dial error:%s", err)
    }
    // Authenticate
    auth := sasl.NewPlainClient("", smtpUser, smtpPassword)
    if err = client.Auth(auth); err != nil {
        log.Fatalf("Auth error:%s", err)
    }
    fmt.Println("from", from)
    // Set sender and recipient
    if err = client.Mail(from, &smtp.MailOptions{
        RequireTLS: false,
    }); err != nil {
        log.Fatalf("MAIL FROM error:%s", err)
    }
    if err = client.Rcpt(email, &smtp.RcptOptions{}); err != nil {
        log.Fatalf("RCPT TO error:%s", err)
    }
    // Write the email body
    wc, err := client.Data()
    if err != nil {
        log.Fatalf("Data error:%s", err)
    }
    var messageContent strings.Builder
    // Use WriteTo to write the message to the buffer
    if _, err := m.WriteTo(&messageContent); err != nil {
        log.Fatalf("Could not convert data into string: %s", err)
    }
    // Convert the message content to a string
    messageString := messageContent.String()
    _, err = wc.Write([]byte(messageString))
    if err != nil {
        log.Fatalf("Write error:%s", err)
    }
    err = wc.Close()
    if err != nil {
        log.Fatalf("Close error:%s", err)
    }
    // Quit the SMTP session
    client.Quit()
    log.Println("Email sent successfully!")
    return
}
  • Node.js
const nodemailer = require('nodemailer');

const concurrentRequests = 1;
const totalRequests = 1;

const email = ["<email>"];

const smtpHost = 'smtp.kasplo.com';
const smtpPort = 587;

const smtpUsername = '<user-name>';
const smtpPassword = '<password>';

const transporter = nodemailer.createTransport({
  host: smtpHost,
  port: smtpPort,
  auth: {
    user: smtpUsername,
    pass: smtpPassword,
  }
});

var arr = [];
var totalTime = 0;

function getRandomItem(arr) {
  return arr[Math.floor(Math.random() * arr.length)];
}

async function sendEmail() {
  try {
    let emailRandom = getRandomItem(email);
    let i = Math.floor(Math.random() * 10000) + 1;
    const mailOptions = {
      from: 'Kasplo <info@trans.kasplo.in>',   
      to: emailRandom,
      subject: `Testing on April15 1.0`,
      text: 'Testing text content',
      html: `<b><i>This is a test email for verifying our email standards.</i></b>
      <a href="https://www.google.com">Click here</a>`,
    };

    const start = Date.now();
    await transporter.sendMail(mailOptions);
    const timeTaken = (Date.now() - start) / 1000;
    arr.push(timeTaken);
    totalTime += timeTaken;
    console.log("Email sent to:", emailRandom);
  } catch (error) {
    console.error('Email sending failed:', error);
  }
}

async function runEmailTest() {
  const promises = [];
  for (let i = 0; i < concurrentRequests; i++) {
    promises.push(sendEmail());
  }
  await Promise.all(promises);
}

setTimeout(async () => {
  for (let i = 0; i < totalRequests / concurrentRequests; i++) {
    console.log(`Batch ${i + 1}`);
    await runEmailTest();
  }
  console.log("Average time taken: %s", totalTime / arr.length);
}, 1000);
  • Java

import java.util.Properties;
import javax.mail.*;
import javax.mail.internet.*;

public class EmailSender {
    public static void main(String[] args) {
        String smtpHost = "smtp.kasplo.com";
        int smtpPort = 587;
        String smtpUsername = "<user-name>";
        String smtpPassword = "<password>";
        String from = "Kasplo <info@trans.kasplo.in>";
        String to = "<email>";
        String subject = "Testing on April15 1.0";
        String htmlContent = "<b><i>This is a test email for verifying our email standards.</i></b>" +
                             "<a href='https://www.google.com'>Click here</a>";

        Properties props = new Properties();
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.host", smtpHost);
        props.put("mail.smtp.port", String.valueOf(smtpPort));

        Session session = Session.getInstance(props, new javax.mail.Authenticator() {
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(smtpUsername, smtpPassword);
            }
        });

        try {
            Message message = new MimeMessage(session);
            message.setFrom(new InternetAddress("info@trans.kasplo.in", "Kasplo"));
            message.setRecipients(Message.RecipientType.TO, InternetAddress.parse(to));
            message.setSubject(subject);
            message.setContent(htmlContent, "text/html; charset=UTF-8");
            Transport.send(message);
            System.out.println("Email sent successfully!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Contact & Support

Email: support@kasplo.com

Website: https://www.kasplo.com

Stay tuned for more updates and integrations!

SMTP Send

SMTP Host : smtp.kasplo.com

Port: 587 
 Authentication: Username & Password (shared post-onboarding)

Supported Events

  • Open: Triggered when a recipient opens the email, typically tracked by an embedded image or pixel.

{      
  "click_tracking_id": "9307750b-76cb-42e7-83b5-f83462e6b646:0",
  "email": "recipient@example.com",
  "engine_ip": "185.240.76.223",
  "event_type": "engine_open",
  "sendid": "testdev250207",
  "timestamp": "1738908485",
  "tags": "custom-id-value"
}
  • Click: Occurs when a recipient clicks on a link within the email, showing interaction with your content.

{      
  "click_tracking_id": "9307750b-76cb-42e7-83b5-f83462e6b646:0",
  "email": "recipient@example.com",
  "engine_ip": "185.240.76.223",
  "event_type": "engine_open",
  "sendid": "testdev250207",
  "timestamp": "1738908485",
  "tags": "custom-id-value"
}
  • Unsubscribe: Triggered when a recipient opts out of future emails.

{      
  "click_tracking_id": "9307750b-76cb-42e7-83b5-f83462e6b646:0",
  "email": "recipient@example.com",
  "event_type": "engine_unsub",
  "sendid": "testdev250207",
  "timestamp": "1738908785",
"tags": "custom-id-value"

}
  • Spam_complaint: Occurs when a recipient marks the email as spam, which can affect your sender reputation.

{      
  "click_tracking_id": "9307750b-76cb-42e7-83b5-f83462e6b646:0",
  "email": "recipient@example.com",
  "event_type": "engine_unsub",
  "sendid": "testdev250207",
  "timestamp": "1738908785",
"tags": "custom-id-value"

}
  • Bounce_all: Triggered when an email cannot be delivered. Bounces can be either hard (permanent failure) or soft (temporary issue).

{
  "bounce_code": "10",
  "bounce_text": "142.251.185.27 does not like recipient.\nRemote host said: 550 5.1.1 The email account that you tried to reach does not exist. Please try\n5.1.1 double-checking the recipient's email address for typos or\n5.1.1 unnecessary spaces. For more information, go to\n5.1.1  https://support.google.com/mail/?p=NoSuchUser 6a1803df08f44-6e4420eb7b0si16201796d6.287 - gsmtp",
  "bounce_type": "h",
  "click_tracking_id": "615cd17d-9c5e-428c-9ca1-1ba0aef6bfcd:0",
  "email": "recipient@example.com,
  "event_type":  
  "listid": "testdev1",
  "sendid": "testdev250207",
  "timestamp": "1738908517",
  "tags": "custom-id-value-here"
}
  • Bounce_bad_address: Triggered when an email fails to deliver due to an invalid, non-existent, or malformed email address.

{
  "bounce_code": "10",
  "bounce_text": "142.250.111.27 does not like recipient.\nRemote host said: 553 5.1.3 The recipient address  is\n5.1.3 not a valid RFC 5321 address. For more information, go to\n5.1.3  https://support.google.com/a/answer/3221692 and review RFC 5321\n5.1.3 specifications. af79cd13be357-7c7a894bccbsi952141885a.120 - gsmtp",
  "bounce_type": "h",
  "click_tracking_id": "239485cc2d5a681db7a8337e740f8090",
  "email": "recipient@example.com",
  "event_type": "bounce",
  "listid": "testdev1",
  "sendid": "testdev250415",
 "tags": "custom-id-value-here"
}
  • Delivery_attempt: Triggered when an email is handed off for delivery. It indicates an attempt to reach the recipient’s server but doesn’t confirm delivery to the inbox.

{
  "click_tracking_id": "9307750b-76cb-42e7-83b5-f83462e6b646:0",
  "email": "recipient@example.com",
  "event_type": "delivery_attempt",
  "from_address": "replay@trans.kasplo.in",
  "injected_time": "1738908430",
  "listid": "testdev1",
  "message": "142.251.185.27 accepted message./Remote host said: 250 2.0.0 OK  1738908432 d75a77b69052e-47153b9056fsi25554051cf.364 - gsmtp/",
  "outmtaid_ip": "103.94.241.19",
  "sendid": "sendid",
  "status": "success",
  "timestamp": "1738908434",
  "tags": "custom-id-value-here"
}

Key Descriptions

  • click_tracking_id: A unique ID (if set via SMTP/API header) that ties the event back to a specific email send. Useful for tracking across multiple events, like open and click.
  • email: The recipient’s email address for whom the event occurred.
  • event_type: Identifies the type of event (e.g., engine_open, engine_click, bounce, delivery_attempt).
  • sendid: A unique ID for the email campaign or transactional message. Set by you or generated by Kasplo.
  • timestamp: The time the event was recorded, in Unix epoch format.
  • tags: Custom metadata or identifier passed during email send (can be used for internal reference or tagging).

Changelog

Introducing Email Verification 2nd May 2025
Version: 1.1.01

New Feature: Email Verification - Real-time list cleaning

We are excited to introduce a powerful enhancement to Kasplo - Email Verification, A real-time contact list cleaning. This new capability allows you to instantly validate and clean your contact lists, ensuring your email campaigns reach verified, engaged recipients.

With this feature, you can:

Verify email addresses in real-time: Instantly identify the validity of each email address in your list, classifying them based on verification outcomes.

Clean your contact lists: Remove invalid, risky, or undeliverable email addresses from your lists automatically, improving deliverability.

Maintain a high-quality database: Keep your global contact database free from low-quality or problematic addresses, ensuring better campaign performance.

This functionality is seamlessly integrated into your Kasplo account, allowing you to clean and optimize any list before adding it to your global contact database or specific marketing lists.

 

How it works: Real-time email verification system

Our verification process uses advanced SMTP checks and server-level diagnostics to accurately classify each email address, ensuring only verified and safe addresses are used for campaigns:

  1. DNS & MX Record lookup: Identifies if the recipient's domain is configured to receive emails.
  2. SMTP handshake: Establishes a direct connection with the recipient's mail server for real-time verification.
  3. Mailbox validation: Verifies the existence of the recipient's mailbox using standard email protocol commands.
  4. Response code analysis: Interprets server responses to classify the email status with precision.
  5. Status assignment: Each email is categorized based on server behavior and response codes.

Email verification statuses explained

Kasplo uses a clear, color-coded classification system to indicate the status of each email address in your list:

Status Send/Not Description Action Recommendation
Good Yes Fully verified and deliverable mailbox. Safe to send.  Send confidently without any risks.
Unverified Yes (Cautious) Unable to confirm mailbox (e.g., catch-all domains like Gmail). Safe for known domains.  Send with caution for unknown domains.
Greylisted Retry (6-12 hours) Temporarily deferred by the recipient's server. Retry in 6–12 hours.  Automatically retry later.
Timeout Retry (6-12 hours) No response from the server (may be temporary).  Retry verification after a few hours.
BadEmail No Invalid mailbox—will hard bounce if sent.  Remove immediately from your list.
Bad No SMTP error or rejected connection (unauthorized, blacklisted).  Investigate sender reputation or domain issues.
Unknown No Domain or server unreachable (DNS or MX issue).  Review domain configuration and retry.
Skipped No Verification was bypassed due to billing issues.  Resolve billing or account issues.

 

Why this matters for your email campaigns

Higher Deliverability: By sending only to verified addresses, your emails are more likely to land in inboxes, not spam folders.

Reduced Bounce Rates: Eliminate the risk of hard bounces that damage your sender reputation.

Cleaner Lists, Better Engagement: Maintain a healthy database by removing invalid or risky contacts, leading to higher open and click rates.

Seamless List Management: Easily clean, validate, and upload contact lists to any marketing list or your global contact database.

 

Start sending smarter with Kasplo

Refer to this to understand Email Verification in deatil. Get a clean & precise list, now available for all eligible users at app.kasplo.com.

Transactional Feature Integration on app.kasplo.com 16th Apr 2025
Version 1.0.16

Overview

This release marks a major milestone in Kasplo’s evolution toward a unified, powerful email marketing and infrastructure suite. With Version 1.0.16, we have officially integrated SMTP/API-based transactional email capabilities directly into our core platform, eliminating silos, reducing operational overhead, and providing a seamless experience for both marketing and infrastructure users.

New feature: Transactional email module

A dedicated “Transactional” section is now available within Kasplo's primary application for clients leveraging SMTP or API-based email infrastructure. This new module is purpose-built to manage mission-critical emails such as OTPs, system alerts, confirmations, and receipts.

Functional capabilities

  • Unified dashboard
     A centralized command center to oversee both transactional and marketing email activity, ensuring complete visibility into your communication ecosystem.
  • Live activity feed
     Monitor real-time event streams, deliveries, opens, clicks, bounces, and failures—without switching tabs or tools.
  • Advanced analytics & reporting
     Gain insights into performance metrics, including delivery rates, engagement trends, and error diagnostics with granular, time-filtered reporting.
  • Flexible data export
     Export detailed event logs, statistical reports, and delivery outcomes in CSV or JSON format for custom analytics or archiving.
  • Transactional suppression lists
     Maintain dedicated suppression rules for transactional email, independent of marketing consent preferences, ensuring compliance with regulatory requirements.

 Platform consolidation

Previously hosted under a separate subdomain (webhook.kasplo.com), transactional email operations are now natively integrated into the main application interface. This consolidation simplifies workflows, aligns reporting, and centralizes team collaboration.

Access & configuration

The transactional email module is not enabled by default. Access is provisioned through a Super Admin workflow to maintain platform security and feature eligibility.

  • Enablement process:
    • Super Admins can activate the module for specific users by assigning the appropriate User ID and Mail Class.
    • Only users with explicit permissions will be able to view and configure transactional credentials.

Benefits of this update

 Unified ecosystem

Operate all your email communication, marketing campaigns, transactional messages, and deliverability monitoring within one login and dashboard.

 Operational efficiency

Reduce training and navigation complexity for teams managing both promotional and system-driven email streams.

 Enhanced access control

Implement role-based permissions to safeguard infrastructure access and enforce user-level policies.

 Developer-centric design

Benefit from streamlined API endpoints, easy onboarding documentation, and integrated log visibility to accelerate development cycles.

 Better monitoring, fewer errors

Track message performance with rich logs, real-time feedback, and historical reports—reducing delivery failures and optimizing engagement.

Improved performance, API Optimizations, and reporting Accuracy 6th Mar 2025
Version: 1.0.12

Feature enhancements & improvements

Enhanced campaign listing page

Improved visibility into campaign engagement by updating metrics to display unique opens and unique clicks, enabling more accurate performance analysis.

Accurate delivery stats in CSV exports

Refined download stats to correctly reflect DLR (Delivered) statuses, ensuring exported campaign performance reports are precise and audit-ready.

Faster large-scale segmentation exports

Optimized segmentation exports for large datasets (exceeding 1 crore records) with custom fields. Now supports high-volume downloads with improved processing efficiency—5.4GB files processed in ~1.3 hours.

 

Campaign list API acceleration

Significantly enhanced API response time for campaign listings. Page loads now return in 220–360 ms, providing a noticeably faster user experience, even at scale.

Fixes & stability updates

  • Seed list export
     Export reliability improved for seed lists. Users can now generate and download files without interruption.
  • Suppression list export
     Fixed inconsistencies in suppression exports. Lists now download with complete and accurate data.

Introducing Kasplo Email Intelligence 1st Mar 2025
1.0.10

New feature: Kasplo email intelligence

Kasplo Email Intelligence is now live — delivering unmatched visibility, clarity, and competitive edge to email marketers. Built to eliminate blind spots, this release transforms how brands monitor, optimize, and outperform in the inbox.

Core modules & capabilities

 Inbox tracker

Gain detailed inbox placement insights across ISPs, including read rate, delete rate, and tab classification (Primary, Promotions, Updates, Spam). Understand exactly how subscribers engage with your emails and fine-tune your strategy for maximum visibility.

 Reputation & blacklist monitoring

Monitor your domain and IP health in real-time. Get proactive alerts for spam traps, blacklisting, and complaint spikes, empowering you to take action before your deliverability takes a hit.

 EI Vault (Competitive Intelligence)

Track what’s working for your competitors, subject lines, templates, send times, and inbox placement. Discover trends, analyze high-performing tactics, and leverage these insights to optimize your own campaigns for better engagement and ROI.

 Why it matters

  • 360° Visibility: One dashboard that replaces fragmented tools and gives you everything—from inbox behavior to competitor benchmarks.
  • Data-informed decisions: Eliminate guesswork and make smarter campaign choices backed by actionable insights.
  • First-of-its-kind in india: Kasplo is the only email marketing platform in India offering end-to-end campaign intelligence in a single interface.
  • Made for marketers: Purpose-built for email marketers, growth teams, and brands who want to outperform—not just compete.

 The Impact

  • Reduced time spent juggling multiple tools
  • Higher inbox placement and engagement accuracy
  • Competitive clarity that helps your campaigns stand out
  • Real-time response to reputation threats before they become problems

Kasplo Email Intelligence adds a strategic advantage. Now available for all eligible users on app.kasplo.com.

Scroll to Top