• Getting started
  • Advanced Features
Sending Options
  • API Send Post
  • Custom header
  • SMTP Send Post
  • Custom header
  • AMP Email
  • Python / Ruby
  • PHP
  • GoLang
  • Node.js
  • Java
  • Introduction
  • Sample response
  • Bounce Events
  • Delivery Attempt
  • Unsubscribe
  • Email Intelligence (EI)
  • SDKs
  • Contact & Support

Getting Started

This section will guide you through the essential setup steps required to start sending emails using our powerful infrastructure.

Account Access & Onboarding

Kasplo does not support open sign-ups. All clients are manually onboarded to ensure optimal setup and deliverability. Upon onboarding, you will receive your SMTP credentials and access to your client portal.

DNS Configuration

For successful email delivery and sender authentication, clients must configure the following DNS records:

  • SPF (Sender Policy Framework): Authorizes Kasplo servers to send emails on behalf of your domain.
  • DKIM (DomainKeys Identified Mail): Ensures email integrity and helps prevent spoofing by digitally signing messages.
  • DMARC (Domain-based Message Authentication, Reporting & Conformance): Enforces policies on SPF/DKIM alignment and provides visibility through reports.
  • Tracking Domain: Customizes and masks tracking links for better branding and improved deliverability.

You will receive all necessary DNS record values during onboarding. Please add them to your domain registrar’s DNS settings to activate sending.

Webhook Configuration

To receive real-time email events (such as opens, clicks, bounces, etc.), clients must provide a valid Event Notification URL.

Kasplo will post structured JSON payloads to this endpoint for all supported events.

Data Retention

Event logs and metadata are retained for 60 days by default. Extended data retention plans are available upon request.

Authentication Methods

Kasplo supports two methods of authentication:

SMTP Authentication:

API Authentication:

  • Generate and manage your API keys from the Settings section in your client portal.
  • Use the key as a Bearer token in the Authorization header for all API requests.

Once these steps are completed, you’re ready to start sending with Kasplo. For more advanced configurations and examples, explore the following sections in this documentation.

  •  

Email API

Kasplo’s Email API enables developers to send transactional and marketing emails programmatically with speed, reliability, and full control. Designed for scale, our API is built to support high-volume email sending while ensuring top-tier deliverability through advanced infrastructure and intelligent routing.Whether you’re sending a password reset, order confirmation, or a promotional blast, our Email API gives you:
  • Seamless integration with your backend system
  • Real-time email delivery with status tracking
  • Built-in support for custom headers, personalization, and tags
  • Detailed analytics and bounce handling
In the sections below, you’ll find everything you need to get started: endpoint details, required headers, request structure, and sample responses to implement Kasplo’s Email API into your application with ease.

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",
 }

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.

Custom header X-Kasplo-Click-Tracking-ID

Kasplo allows you to include a custom tracking identifier in your email request payload. This identifier helps link events across systems and is returned in webhook responses under the tags field.
Note: Although the name resembles a header, x-kasplo-click-tracking-id must be passed as a field in the request body, not as an HTTP header.

Field Name (in request body):


{
  "x-kasplo-click-tracking-id": "your-tracking-id"
}
Field Type: string Allowed Characters: Printable ASCII characters (character codes 32–126) Max Length: 200 characters Best Practice: Use concise and unique values to minimize payload size and simplify traceability.

Example Request:


{
  "to": "user@example.com",
  "subject": "Welcome to Kasplo!",
  "x-kasplo-click-tracking-id": "123-12-123"
  // other fields...
}

Webhook Response Example:


{
  "event": "click",
  "email": "user@example.com",
  "tags": "123-12-123"
  // other fields...
}

AMP Email Support via SMTP & API

Kasplo supports sending AMP (Accelerated Mobile Pages) emails through both SMTP and Email API, allowing you to deliver rich, interactive experiences directly inside the inbox — such as carousels, forms, accordions, and live data updates.
AMP emails are supported by major ISPs including Gmail, Yahoo Mail, and Mail.ru, but require domain-level approval before you can start sending.

Why Use AMP Emails?

  • Embed dynamic content like forms, polls, or appointment pickers
  • Provide real-time updates within emails (e.g., cart changes, status updates)
  • Improve engagement and reduce redirections to external pages

Integration with Kasplo

1. Via Email API

To send an AMP email via API:
  • Use the content-type: multipart/alternative in your API request
  • Add text/html, text/plain, and text/x-amp-html versions of your content
  • Include appropriate headers such as X-AMP-HTML-Part for AMP sections
Sample payload:

{
  "from": "sender@yourdomain.com",
  "to": "user@example.com",
  "subject": "Welcome to AMP!",
  "html": "Hello (HTML version)",
  "text": "Hello (Plain text version)",
  "amp_html": "...AMP content..."
}

2. Via SMTP

  • Ensure the email is sent as multipart/alternative
  • Include all three parts: plain text, HTML, and AMP HTML
  • Your sending domain must be AMP-approved (see below)
Example (raw MIME format):

Content-Type: multipart/alternative; boundary="XYZ"

--XYZ
Content-Type: text/plain; charset=UTF-8
Hello (plain text)

--XYZ
Content-Type: text/html; charset=UTF-8
Hello (HTML)

--XYZ
Content-Type: text/x-amp-html; charset=UTF-8


  ...
  ...AMP content...


--XYZ--

Approval Process for Sending AMP Emails

Before sending AMP emails, you must be approved by each ISP you plan to send to. Here’s the general process for each:
Gmail (Google)
  1. Enable DKIM, SPF, and DMARC for your sending domain
  2. Use a consistent sending domain and IP with a good reputation
  3. Prepare your AMP email samples and ensure they follow Gmail’s AMP guidelines
  4. Fill out the Gmail AMP Registration Form
  5. Wait for Gmail’s approval (usually 5–7 working days)

Yahoo Mail

  1. Same as Gmail — DKIM, SPF, and DMARC required
  2. Reach out to Yahoo with AMP samples via Yahoo AMP Request Form
  3. Approval turnaround time is 5–10 business days

Mail.ru

  1. Submit your request to postmaster@mail.ru
  2. Share sample AMP messages and domains/IPs you’ll use
  3. Approval is manual and typically takes 7–10 business days

Important Guidelines

  • AMP content must match the plain HTML version in intent
  • You must always include fallback text/plain and text/html versions
  • Use https for all AMP components (images, links, JSON endpoints)
  • Don’t include external JavaScript — only AMP components are allowed
  • Ensure your AMP emails validate using tools like AMP Playground

Need Help?

Our support team can assist you in:
  • Reviewing AMP templates
  • Submitting ISP approval forms
  • Ensuring your infrastructure (SPF/DKIM/DMARC) is correctly configured

 Reach out to us at support@kasplo.com to get started with AMP emails.

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

Kasplo’s infrastructure is designed with performance, flexibility, and enterprise-grade deliverability in mind. Below are the advanced capabilities available to help power your email campaigns at scale.

Performance & Throttling

Kasplo supports high-throughput sending, optimized per plan. We offer:
  • Customizable rate limits based on your plan tier
  • Burst control and auto-throttling to protect reputation during spikes
  • Concurrency tuning for enterprise-grade deliverability

Suppression Management

Stay compliant and protect sender reputation with automatic suppression:
  • Bounces (hard and repeated soft bounces)
  • Spam complaints
  • Unsubscribes
  • Manual suppression: Upload suppression lists via the dashboard or API

IP Pools

Kasplo supports both shared and dedicated IP infrastructure:
  • Shared IPs: Ideal for startups and smaller senders
  • Dedicated IPs (add-on): Recommended for high-volume senders who require full control and reputation isolation

AMP for Email

Send interactive, dynamic AMP emails using Kasplo:
  • Kasplo supports AMP MIME parts in addition to HTML and text
  • AMP forms and endpoints must be client-hosted and HTTPS-enabled
  • Great for use cases like live product galleries, dynamic forms, and in-email actions

Forwarding & Incoming Email Handling

Kasplo supports storing and parsing email replies:
  • View replies directly from your dashboard
  • Route responses to specific teams or inboxes via forwarding rules

Attachments

Easily include attachments with your emails:
  • Supported file types: PDF, DOCX, PNG, JPG, CSV, ZIP
  • Size limits vary by plan (up to 25MB supported in higher tiers)

CC & BCC Tracking

Kasplo provides full support for CC and BCC recipients:
  • Each CC and BCC email is treated as a unique email send, and is counted against your email credits
  • Events like open, click, bounce, complaint, and unsubscribe are individually tracked
  • All recipients (To, CC, BCC) share the same  X-Kasplo-Click-Tracking-ID , allowing you to trace a single message across all recipient paths
 Note: You will receive separate webhook events per recipient (To/CC/BCC), each with distinct delivery and engagement tracking.
  • 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)

Welcome to the comprehensive guide for Kasplo Email Intelligence (EI). Designed for both marketers and developers, this documentation offers a deep dive into every tool and insight available within the platform. Kasplo EI empowers you to optimize your deliverability, reputation, and competitive strategy using real-time data and historical insights.

Getting Started with Kasplo Email Intelligence

Why Email Intelligence Matters

In today’s crowded inboxes, sending emails is not enough — landing in the inbox is everything. Kasplo Email Intelligence is your secret weapon to achieve consistent deliverability, optimize content strategy, and outsmart your competition.

What is Kasplo EI?

Kasplo Email Intelligence is an advanced suite built into your Kasplo Marketing Platform. It gives you:

  • Deep visibility into your sender reputation (Google, Microsoft, DNS, blacklists, etc.)
  • Real-time inbox placement tracking across major ISPs
  • Competitive intelligence and design inspiration through the EI Vault
  • Predictive tools to test inboxing before every campaign

Key Benefits

  • Proactive Deliverability: Spot problems before they hurt your sender score.
  • Real-Time Inboxing Insights: Know where your emails land — across ISPs, devices, tabs.
  • Boost Engagement: Build better subject lines, CTAs, and design using data-backed strategies.
  • Improve Authentication: Ensure consistent DKIM, SPF, DMARC results.
  • Competitor Intelligence: Learn what top brands are doing — and do it better.

Unlock Exclusive Power

The Inbox Pre-Tester is available only to Kasplo EI users. It allows you to preview inbox placement before sending:

  •  Inbox / Spam / Promotions tab results
  •  Authentication (SPF, DKIM, DMARC) success/failure status

Only Kasplo EI subscribers can use the Inbox Tester within the Campaign Send Page. Without EI access, the Pre-Tester feature remains disabled.

And once you send? That’s where Inbox Tracker takes over, monitoring real-user inboxing results and providing real-world placement analytics across the globe.

Get started today and make every email count with Kasplo EI.

1. Dashboard

Overview

The EI Dashboard serves as your control center. Here, you can:

  • View a quick summary of your brand’s domain reputation.
  • Access key metrics and alerts.
  • Navigate to detailed reports across all modules.

Key Elements:

  • Your domain’s performance snapshot
  • Current sender reputation status
  • Deliverability highlights

2. Reputation Tracker

Purpose

The Reputation Tracker helps you monitor and maintain your sender reputation across major ISPs like Google and Microsoft. It provides granular insights into how your domain and IP are being perceived and where improvements are needed.

Modules and Insights

a. Reputation Trends

  • Domain Reputation (Google Postmaster)
  • IP Reputation (Google Postmaster)
  • Microsoft SNDS Data
  • Reputation Change History (track changes over time)

b. Complaints Monitoring

  • Spam Rate (from Google Postmaster)
  • Feedback Loop (complaints reported via Google)
  • Encrypted Traffic ratio
  • Delivery Errors (Gmail-specific issues)
  • Complaints by Domain (Microsoft SNDS)
  • Complaints by IP (Microsoft SNDS)
  • Spam Trap Hits (Microsoft SNDS, third-party feeds)

c. Blacklist Monitor

  • Realtime monitoring across key DNS-based blacklists (Spamhaus, SORBS, etc.)
  • Automatic alerts for blacklisting/delisting
  • Impact analysis and delisting suggestions

d. Authentication Monitoring

  • Authenticated Traffic Rate (success ratios)
  • DKIM Success Rate
  • SPF Success Rate
  • DMARC Success Rate
  • DNS Lookup Reports (SPF, DKIM, DMARC, PTR records)

3. Inbox Tracker

Purpose

The Inbox Tracker provides real-world inbox placement data by leveraging a global network of real users and seed accounts.

Features

  • ISP-Wise Reports (Gmail, Outlook, Yahoo, etc.)
  • Tab Placement Insights (Primary, Promotions, Spam, etc.)
  • Campaign-Wise Tracking (view performance of individual sends)
  • Real-Time Global Seed Testing
  • Device-Based Analysis (mobile vs. desktop)
  • User-Based Behavior Tracking (open rates, click rates by ISP)

Reporting

  • Visual inbox placement heatmaps
  • Time-based performance graphs
  • Exportable insights (CSV, JSON, API)

4. Email Intelligence Vault (EI Vault)

Purpose

EI Vault is your intelligence center for competitive benchmarking, campaign inspiration, and messaging optimization.

Modules

a. Brand Search

  • Find brands by name, domain, or category
  • View historical send trends and summaries

b. Brand Insights

  • Frequency of sends
  • Best days and times
  • Messaging patterns

c. Deliverability Insights

  • Inboxing performance of competitor campaigns
  • ISP-specific deliverability rates

d. Messaging Insights

  • Subject Line Strategies (length, keywords, sentiment)
  • Tone & CTA analysis
  • Personalization tactics

e. Design Inspiration

  • Responsive layout previews (mobile, desktop)
  • Filter by industry, theme, or performance
  • Compare visual hierarchy and creative elements

f. Device View Experience

  • Mobile vs Desktop rendering comparisons
  • Image load behavior & fallback tracking

For Support

Need help or have feedback? Reach out to your CSM or contact us at support@kasplo.com.

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: helpdesk@kasplo.com

Website: https://www.kasplo.com

Stay tuned for more updates and integrations!

SMTP Send

SMTP Credentials

SMTP Host : smtp.kasplo.com

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

Custom header : X-Kasplo-Click-Tracking-ID

Kasplo allows you to associate a custom tracking identifier with every outbound email. This identifier helps link events across systems and is returned in webhook responses under the  tags field.

Field Name (in request body):


      {
  "X-Kasplo-Click-Tracking-ID": "your-tracking-id"
       }

 Field Type.  string
Allowed Characters: Printable ASCII characters (character codes 32–126)
Max Length: 200 characters
Best Practice: Use concise and unique values to minimize payload size and simplify traceability.

Example Request:


     {
  "to": "user@example.com",
  "subject": "Welcome to Kasplo!",
  "X-Kasplo-Click-Tracking-ID": "123-12-123"
  // other fields...
      }

Webhook Response Example: 


     {
  "event": "click",
  "email": "user@example.com",
  "tags": "123-12-123"
  // other fields...
   }

Webhooks

Kasplo supports Webhooks to help you stay in sync with your email delivery lifecycle. Whether you’re sending emails via API or SMTP, the webhook mechanism remains the same and allows you to receive real-time HTTP POST callbacks for various events related to your outbound emails.This lets you:
  • Monitor email delivery performance
  • Capture user interactions like opens and clicks
  • Maintain clean and up-to-date subscriber lists
  • Analyze bounce patterns and deliverability trends

Webhook Configuration

To receive webhook events, configure your webhook endpoint in your Kasplo dashboard. We recommend:

  • Supporting HTTPS for security
  • Responding with HTTP 200 status within 5 seconds
  • Handling retries (in case your endpoint is temporarily unavailable)

Kasplo retries failed webhook deliveries with exponential backoff.

Supported Webhook Events

Here are the webhook events we currently support:

1. delivery_attempt : Represents an attempt to deliver the email to the recipient. Includes detailed results like success, failure, deferral, etc.

2. open : Triggered when a recipient opens the email (based on tracking pixel).

3. click : Triggered when a recipient clicks a tracked link in the email.

4. bounce_all : Fired for every bounce received by the system. It does not mean the recipient should be removed. This event exists primarily for statistical/logging purposes. It includes the bounce type:

  • h = hard bounce
  • s = soft bounce
  • o = other
5. bounce_bad_address : Triggered when the recipient address should no longer be sent to. This typically occurs after the system determines the address is invalid based on repeated bounces. Bounce type is also included  (h ors ).

6. Unsubscribe : Triggered when the recipient unsubscribes by clicking the unsubscribe link. This helps ensure compliance and maintain healthy list hygiene..

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.

Tracked unsubscribe link

Add Unsubscribe 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##

7. spam_complaint : Triggered when the recipient marks the email as spam. This is critical for maintaining sender reputation.

Each webhook event will include structured JSON data and metadata such as recipient, campaign ID, message ID, and timestamp.

In the next section, we’ll go deeper into each event type with example payloads so you can easily integrate them into your workflow.

Sample response

  • Delivery_attempt
Field Description Example Value
event_type The type of event (delivery_attempt) indicating a message delivery attempt was made. delivery_attempt
timestamp The time the delivery attempt occurred, in seconds past the Unix epoch. 1738908434
email The email address to which the delivery was attempted. recipient@example.com
from_address The email address used in the “From” header of the message. sender@yourdomain.com
injected_time The time when the message was injected into the system, in seconds past the Unix epoch. 1738908430
sendid The identifier for the mailing list the message belongs to. sendid
listid The identifier for the mailing list the message belongs to. testdev1
message The response message from the receiving server regarding the delivery status. 142.251.185.27 accepted message./Remote host said: 250 2.0.0 OK...
status Result of the delivery attempt. Can be success, failure, failure_toolong, deferral, or connmaxout. success
outmtaid_ip The IP address of the outbound MTA (Mail Transfer Agent) that attempted the delivery. 103.94.241.19
click_tracking_id The click tracking ID from the X-Kasplo-Click-Tracking-ID header to trace the specific message. 9307750b-76cb-42e7-83b5-f83462e6b646:0
tags The value passed via X-kasplo-Click-Tracking-ID header, useful for grouping or filtering events. custom-id-value-here 

{
  "click_tracking_id": "9307750b-76cb-42e7-83b5-f83462e6b646:0",
  "email": "recipient@example.com",
  "event_type": "delivery_attempt",
  "from_address": "sender@yourdomain.com",
  "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"
}
  • Open
Field Description Example Value
event_type The type of event (engine_open) representing that the recipient opened the email. engine_open
timestamp The time the open was tracked, in seconds past the Unix epoch. 1738908485
email The email address of the recipient who opened the email. recipient@example.com
sendid The internal identifier for the email send operation. testdev250207
click_tracking_id The click tracking ID from the X-Kasplo-Click-Tracking-ID header to trace the specific message. 9307750b-76cb-42e7-83b5-f83462e6b646:0
engine_ip The IP address of the client that triggered the open event. 185.240.76.223
user_agent The user agent string of the browser or client that performed the open. Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36
tags The value passed via x-kasplo-click-tracking-id header, useful for grouping or filtering events. custom-id-value 

{      
  "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
Field Description Example Value
event_type The type of event (engine_click) represents a click on a tracked link. engine_click
timestamp The time the click was tracked, in seconds past the Unix epoch. 1738908485
email The email address of the recipient who clicked the link. recipient@example.com
sendid The internal identifier for the email send operation. testdev250207
click_tracking_id The click tracking ID from the X-Kasplo-Click-Tracking-ID header is used to trace the specific message. 9307750b-76cb-42e7-83b5-f83462e6b646:0
user_agent The user agent string of the browser or client that performed the click. Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.89 Safari/537.36
click_url The actual URL that the user clicked. http://www.example.com
tags The value passed via the x-kasplo-click-tracking-id header, useful for grouping or filtering events. custom-id-value 

{      
  "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"
}
  • Bounce_all
Field Description Example Value
event_type The type of event (bounce_all). bounce_all
timestamp The time that the bounce happened, in seconds past the Unix epoch. 1317305252
email The email address to which this message was sent. recipient@example.com
listid The lowercased identifier for the mailing list that this message is a part of this message is a part of. t99
sendid The lowercased internal identifier for the send. t9920110705
bounce_type The type of bounce. h for hard, s for soft, and o for other. h
bounce_code The code of the type of bounce. 10
bounce_text The text of the failure message. (Up to the number of characters configured.) 1.1.1.1 failed after I sent the message. Remote host said: 554 delivery error: dd This user doesn't have a yahoo.com account (user@yahoo.com) - mta1218.mail.mud.yahoo.com
click_tracking_id The click tracking ID is specified using the X-Kasplo-Click-Tracking-ID header and can be used to trace an event. 1927393
tags The x-kasplo-click-tracking-id custom header value will return in this field. custom-id-value 

{
  "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
Field Description Example Value
event_type The type of event (bounce_bad_address). bounce_bad_address
timestamp The time that the bounce happened, in seconds past the Unix epoch. 1317305252
email The email address that this message was sent to. recipient@example.com
listid The lowercased identifier for the mailing list that this message is a part of. t99
sendid The lowercased internal identifier for the send. t9920110705
bounce_type The type of bounce. h for hard, s for soft, and o for other. h
bounce_code The code of the type of bounce. 10
bounce_text The text of the failure message. This typically indicates the reason why the address is undeliverable. 553 5.1.3 The recipient address is not a valid RFC 5321 address.
click_tracking_id The click tracking ID is specified using the X-Kasplo-Click-Tracking-ID header and can be used to trace an event. 239485cc2d5a681db7a8337e740f8090
tags The x-kasplo-click-tracking-id custom header value will return in this field. custom-id-value 

{
  "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"
}
  • Unsubscribe

{      
  "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"

}
Field Description Example Value
event_type The type of event (engine_unsub) indicating the recipient unsubscribed from future emails. engine_unsub
timestamp The time the unsubscribe action was recorded, in seconds past the Unix epoch. 1738908785
email The email address of the recipient who unsubscribed. recipient@example.com
sendid The internal identifier for the email send operation. testdev250207
click_tracking_id The click tracking ID from the X-Kasplo-Click-Tracking-ID header to trace the specific message. 9307750b-76cb-42e7-83b5-f83462e6b646:0
tags The value passed via x-kasplo-click-tracking-id header, useful for grouping or filtering events. custom-id-value
  • Spam_complaint
Field Description Example Value
event_type The type of event (scomp) representing a spam complaint by the recipient. scomp
timestamp The time the complaint was received, in seconds past the Unix epoch. 1738908785
email The email address of the recipient who complained. recipient@example.com
sendid The internal identifier for the email send operation. testdev250207
click_tracking_id The click tracking ID from the X-Kasplo-Click-Tracking-ID header to trace the specific message. 9307750b-76cb-42e7-83b5-f83462e6b646:0
tags The value passed via x-kasplo-click-tracking-id header, useful for grouping or filtering events. custom-id-value 

{      
  "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"

}

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