Schedule Emails

{
  "scheduled_at": "2026-01-20T15:30:00",
  "timezone": "Asia/Kolkata",
  "email": { ... }
}

{
  "scheduled_at": "2026-01-20_15:30:00",
  "timezone": "Asia/Kolkata",
  "email": { ... }
}

// Schedule email
async function scheduleEmail(scheduledAt, timezone, emailData) {
  const response = await fetch('https://api.keplars.com/api/v1/send-email/schedule', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.KEPLERS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      scheduled_at: scheduledAt,
      timezone: timezone,
      email: emailData
    })
  });

  return response.json();
}

// Schedule using simplified format (recommended for readability)
const result = await scheduleEmail(
  '2026-01-21_09:00:00',
  'America/New_York',
  {
    from: '[email protected]',
    from_name: 'Onboarding Team',
    to: ['[email protected]'],
    subject: 'Welcome to our platform!',
    html: '<h1>Welcome!</h1><p>We are excited to have you.</p>',
  }
);

console.log('Scheduled email ID:', result.id);

// Cancel scheduled email
async function cancelScheduledEmail(emailId, reason) {
  const response = await fetch(`https://api.keplars.com/api/v1/send-email/scheduled/${emailId}`, {
    method: 'DELETE',
    headers: {
      'Authorization': `Bearer ${process.env.KEPLERS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ reason })
  });

  return response.json();
}

// Cancel if needed
await cancelScheduledEmail(result.id, 'Campaign postponed');

// List all scheduled emails
async function listScheduledEmails(status) {
  const url = new URL('https://api.keplars.com/api/v1/send-email/scheduled');
  if (status) url.searchParams.append('status', status);

  const response = await fetch(url, {
    headers: {
      'Authorization': `Bearer ${process.env.KEPLERS_API_KEY}`
    }
  });

  return response.json();
}

const scheduledEmails = await listScheduledEmails('scheduled');
console.log(`You have ${scheduledEmails.count} scheduled emails`);

interface EmailData {
  to: string[];
  cc?: string[];
  bcc?: string[];
  subject?: string;
  html?: string;
  template_id?: string;
  params?: Record<string, any>;
}

interface ScheduleEmailResponse {
  id: string;
  object: string;
  status: string;
  scheduled_at: string;
  timezone: string;
  from: string;
  to: string[];
  subject: string;
  created_at: string;
  metadata: {
    estimated_delivery: string;
    recipients_count: number;
  };
}

// Schedule email
async function scheduleEmail(
  scheduledAt: string,
  timezone: string,
  emailData: EmailData
): Promise<ScheduleEmailResponse> {
  const response = await fetch('https://api.keplars.com/api/v1/send-email/schedule', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.KEPLERS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      scheduled_at: scheduledAt,
      timezone: timezone,
      email: emailData
    })
  });

  if (!response.ok) {
    throw new Error(`Failed to schedule email: ${response.statusText}`);
  }

  return response.json();
}

// Schedule using simplified format (recommended)
const result = await scheduleEmail(
  '2026-01-21_09:00:00',
  'America/New_York',
  {
    from: '[email protected]',
    from_name: 'Onboarding Team',
    to: ['[email protected]'],
    subject: 'Welcome to our platform!',
    html: '<h1>Welcome!</h1><p>We are excited to have you.</p>',
  }
);

console.log('Scheduled email ID:', result.id);

// Cancel scheduled email
async function cancelScheduledEmail(
  emailId: string,
  reason?: string
): Promise<{ success: boolean; message: string }> {
  const response = await fetch(`https://api.keplars.com/api/v1/send-email/scheduled/${emailId}`, {
    method: 'DELETE',
    headers: {
      'Authorization': `Bearer ${process.env.KEPLERS_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ reason })
  });

  return response.json();
}

// List all scheduled emails
async function listScheduledEmails(status?: string) {
  const url = new URL('https://api.keplars.com/api/v1/send-email/scheduled');
  if (status) url.searchParams.append('status', status);

  const response = await fetch(url, {
    headers: {
      'Authorization': `Bearer ${process.env.KEPLERS_API_KEY}`
    }
  });

  return response.json();
}

const scheduledEmails = await listScheduledEmails('scheduled');
console.log(`You have ${scheduledEmails.count} scheduled emails`);

import requests
from datetime import datetime, timedelta
import pytz
from typing import Dict, List, Optional

API_KEY = "your_api_key_here"
BASE_URL = "https://api.keplars.com/api/v1/send-email"

def schedule_email(
    scheduled_at: str,
    timezone: str,
    email_data: Dict
) -> Dict:
    """Schedule an email for future delivery."""
    response = requests.post(
        f"{BASE_URL}/schedule",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "scheduled_at": scheduled_at,
            "timezone": timezone,
            "email": email_data
        }
    )
    response.raise_for_status()
    return response.json()

# Schedule using simplified format (recommended)
result = schedule_email(
    "2026-01-21_09:00:00",
    "America/New_York",
    {
        "from": "[email protected]",
        "from_name": "Daily Reports",
        "to": ["[email protected]"],
        "subject": "Your Daily Report",
        "html": "<h1>Daily Report</h1><p>Here is your report...</p>",
    }
)

print(f"Scheduled email ID: {result['id']}")

def cancel_scheduled_email(email_id: str, reason: Optional[str] = None) -> Dict:
    """Cancel a scheduled email."""
    response = requests.delete(
        f"{BASE_URL}/scheduled/{email_id}",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={"reason": reason} if reason else {}
    )
    response.raise_for_status()
    return response.json()

def list_scheduled_emails(status: Optional[str] = None) -> Dict:
    """List all scheduled emails, optionally filtered by status."""
    params = {"status": status} if status else {}
    response = requests.get(
        f"{BASE_URL}/scheduled",
        headers={"Authorization": f"Bearer {API_KEY}"},
        params=params
    )
    response.raise_for_status()
    return response.json()

scheduled = list_scheduled_emails("scheduled")
print(f"You have {scheduled['count']} scheduled emails")

package main

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

const baseURL = "https://api.keplars.com/api/v1/send-email"

type EmailData struct {
    From       string                 `json:"from,omitempty"`
    FromName   string                 `json:"from_name,omitempty"`
    To         []string               `json:"to"`
    CC         []string               `json:"cc,omitempty"`
    BCC        []string               `json:"bcc,omitempty"`
    Subject    string                 `json:"subject,omitempty"`
    HTML       string                 `json:"html,omitempty"`
    TemplateID string                 `json:"template_id,omitempty"`
    Params     map[string]interface{} `json:"params,omitempty"`
}

type ScheduleRequest struct {
    ScheduledAt string    `json:"scheduled_at"`
    Timezone    string    `json:"timezone"`
    Email       EmailData `json:"email"`
}

type ScheduleResponse struct {
    ID          string    `json:"id"`
    Object      string    `json:"object"`
    Status      string    `json:"status"`
    ScheduledAt string    `json:"scheduled_at"`
    Timezone    string    `json:"timezone"`
    From        string    `json:"from"`
    To          []string  `json:"to"`
    Subject     string    `json:"subject"`
    CreatedAt   string    `json:"created_at"`
}

func scheduleEmail(scheduledAt time.Time, timezone string, emailData EmailData) (*ScheduleResponse, error) {
    return scheduleEmailByString(scheduledAt.Format("2006-01-02T15:04:05"), timezone, emailData)
}

func scheduleEmailByString(scheduledAt string, timezone string, emailData EmailData) (*ScheduleResponse, error) {
    apiKey := os.Getenv("KEPLERS_API_KEY")

    reqBody := ScheduleRequest{
        ScheduledAt: scheduledAt,
        Timezone:    timezone,
        Email:       emailData,
    }

    jsonData, err := json.Marshal(reqBody)
    if err != nil {
        return nil, err
    }

    req, err := http.NewRequest("POST", baseURL+"/schedule", bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, err
    }

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

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    var result ScheduleResponse
    if err := json.Unmarshal(body, &result); err != nil {
        return nil, err
    }

    return &result, nil
}

func cancelScheduledEmail(emailID string, reason string) error {
    apiKey := os.Getenv("KEPLERS_API_KEY")

    cancelReq := map[string]string{"reason": reason}
    jsonData, _ := json.Marshal(cancelReq)

    req, err := http.NewRequest("DELETE", baseURL+"/scheduled/"+emailID, bytes.NewBuffer(jsonData))
    if err != nil {
        return err
    }

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

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    return nil
}

func main() {
    // Schedule using simplified format
    // Note: Pass the datetime string directly to scheduleEmail
    // Modify scheduleEmail to accept string instead of time.Time for easier usage

    result, err := scheduleEmailByString(
        "2026-01-21_09:00:00",
        "America/New_York",
        EmailData{
            From:     "[email protected]",
            FromName: "Reports Team",
            To:       []string{"[email protected]"},
            Subject:  "Your Daily Report",
            HTML:     "<h1>Daily Report</h1><p>Here is your report...</p>",
        },
    )

    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    fmt.Printf("Scheduled email ID: %s\n", result.ID)

    // Cancel if needed
    err = cancelScheduledEmail(result.ID, "Campaign postponed")
    if err != nil {
        fmt.Printf("Cancel error: %v\n", err)
    }
}

<?php

class KeplarsEmailScheduler {
    private $apiKey;
    private $baseURL = 'https://api.keplars.com/api/v1/send-email';

    public function __construct($apiKey) {
        $this->apiKey = $apiKey;
    }

    public function scheduleEmail($scheduledAt, $timezone, $emailData) {
        $data = [
            'scheduled_at' => $scheduledAt,
            'timezone' => $timezone,
            'email' => $emailData
        ];

        return $this->makeRequest('POST', '/schedule', $data);
    }

    public function cancelScheduledEmail($emailId, $reason = null) {
        $data = $reason ? ['reason' => $reason] : [];
        return $this->makeRequest('DELETE', "/scheduled/{$emailId}", $data);
    }

    public function listScheduledEmails($status = null) {
        $url = '/scheduled';
        if ($status) {
            $url .= '?status=' . urlencode($status);
        }
        return $this->makeRequest('GET', $url);
    }

    private function makeRequest($method, $endpoint, $data = null) {
        $ch = curl_init($this->baseURL . $endpoint);

        $headers = [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json'
        ];

        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);

        if ($data && ($method === 'POST' || $method === 'DELETE')) {
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
        }

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode >= 400) {
            throw new Exception("API request failed with status {$httpCode}: {$response}");
        }

        return json_decode($response, true);
    }
}

// Usage example
$apiKey = getenv('KEPLERS_API_KEY');
$scheduler = new KeplarsEmailScheduler($apiKey);

// Schedule using simplified format (recommended)
$result = $scheduler->scheduleEmail(
    '2026-01-21_09:00:00',
    'America/New_York',
    [
        'from' => '[email protected]',
        'from_name' => 'Reports Team',
        'to' => ['[email protected]'],
        'subject' => 'Your Daily Report',
        'html' => '<h1>Daily Report</h1><p>Here is your report...</p>'
    ]
);

echo "Scheduled email ID: {$result['id']}\n";

// Cancel if needed
$scheduler->cancelScheduledEmail($result['id'], 'Campaign postponed');

// List scheduled emails
$scheduled = $scheduler->listScheduledEmails('scheduled');
echo "You have {$scheduled['count']} scheduled emails\n";
?>