Best AI Email Tools for Small Business on a Budget: 2025 Comparison Guide

from typing import Dict, List

def calculate_email_tool_cost(
    subscribers: int,
    monthly_emails: int,
    platforms: List[Dict[str, any]]
) -> List[Dict[str, any]]:
    """
    Calculate true monthly cost across email platforms based on your usage.

    Args:
        subscribers: Number of email subscribers
        monthly_emails: Total emails sent per month
        platforms: List of platform pricing configs

    Returns:
        Sorted list of platforms by total monthly cost
    """
    results = []

    for platform in platforms:
        try:
            # Determine base price based on subscriber tiers
            base_price = 0
            for tier in platform['pricing_tiers']:
                if subscribers <= tier['max_subscribers']:
                    base_price = tier['price']
                    break

            # Calculate overage fees if applicable
            overage_cost = 0
            if 'email_limit' in platform and monthly_emails > platform['email_limit']:
                overage_emails = monthly_emails - platform['email_limit']
                overage_cost = (overage_emails / 1000) * platform.get('overage_rate', 0)

            # Calculate additional feature costs
            ai_feature_cost = platform.get('ai_addon_cost', 0) if subscribers > platform.get('ai_included_threshold', 0) else 0

            total_monthly_cost = base_price + overage_cost + ai_feature_cost

            results.append({
                'platform': platform['name'],
                'base_price': base_price,
                'overage_cost': round(overage_cost, 2),
                'ai_cost': ai_feature_cost,
                'total_monthly': round(total_monthly_cost, 2),
                'annual_cost': round(total_monthly_cost * 12, 2),
                'cost_per_subscriber': round(total_monthly_cost / subscribers, 4) if subscribers > 0 else 0
            })
        except Exception as e:
            print(f"Error calculating cost for {platform.get('name', 'Unknown')}: {e}")
            continue

    return sorted(results, key=lambda x: x['total_monthly'])

# Example: Small business with 1,500 subscribers, 6,000 emails/month
platforms_config = [
    {
        'name': 'Brevo',
        'pricing_tiers': [
            {'max_subscribers': 1000, 'price': 8.08},
            {'max_subscribers': 2500, 'price': 16.17},
            {'max_subscribers': 5000, 'price': 27}
        ],
        'ai_addon_cost': 0  # Included
    },
    {
        'name': 'MailerLite',
        'pricing_tiers': [
            {'max_subscribers': 1000, 'price': 0},
            {'max_subscribers': 2500, 'price': 18},
            {'max_subscribers': 5000, 'price': 30}
        ],
        'ai_addon_cost': 0  # Included in paid
    },
    {
        'name': 'ActiveCampaign',
        'pricing_tiers': [
            {'max_subscribers': 1000, 'price': 15},
            {'max_subscribers': 2500, 'price': 49},
            {'max_subscribers': 5000, 'price': 79}
        ],
        'ai_addon_cost': 0
    },
    {
        'name': 'Klaviyo',
        'pricing_tiers': [
            {'max_subscribers': 500, 'price': 20},
            {'max_subscribers': 1500, 'price': 35},
            {'max_subscribers': 2500, 'price': 60}
        ],
        'email_limit': 5000,
        'overage_rate': 0.50
    }
]

cost_comparison = calculate_email_tool_cost(1500, 6000, platforms_config)

print("Email Platform Cost Comparison (1,500 subscribers, 6,000 emails/mo)")
print("=" * 75)
for platform in cost_comparison:
    print(f"{platform['platform']:<20} ${platform['total_monthly']:>7.2f}/mo | ${platform['annual_cost']:>8.2f}/yr | ${platform['cost_per_subscriber']:.4f}/subscriber")

# Output:
# Email Platform Cost Comparison (1,500 subscribers, 6,000 emails/mo)
# ===========================================================================
# Brevo                $  16.17/mo | $  194.04/yr | $0.0108/subscriber
# MailerLite           $  18.00/mo | $  216.00/yr | $0.0120/subscriber
# Klaviyo              $  35.50/mo | $  426.00/yr | $0.0237/subscriber
# ActiveCampaign       $  49.00/mo | $  588.00/yr | $0.0327/subscriber

import requests
from typing import Dict, List

class BrevoEmailAPI:
    """Simple wrapper for Brevo (formerly Sendinblue) API integration."""

    def __init__(self, api_key: str):
        """
        Initialize Brevo API client.

        Args:
            api_key: Your Brevo API key from account settings
        """
        self.api_key = api_key
        self.base_url = "https://api.brevo.com/v3"
        self.headers = {
            "accept": "application/json",
            "api-key": self.api_key,
            "content-type": "application/json"
        }

    def send_email(
        self,
        to_email: str,
        to_name: str,
        subject: str,
        html_content: str,
        from_email: str = "hello@yourbusiness.com",
        from_name: str = "Your Business"
    ) -> Dict[str, any]:
        """
        Send a single email via Brevo API.

        Args:
            to_email: Recipient email address
            to_name: Recipient name
            subject: Email subject line
            html_content: HTML email body
            from_email: Sender email (must be verified in Brevo)
            from_name: Sender display name

        Returns:
            API response with message ID
        """
        url = f"{self.base_url}/smtp/email"

        payload = {
            "sender": {"name": from_name, "email": from_email},
            "to": [{"email": to_email, "name": to_name}],
            "subject": subject,
            "htmlContent": html_content
        }

        try:
            response = requests.post(url, json=payload, headers=self.headers)
            response.raise_for_status()
            return {"success": True, "message_id": response.json().get("messageId")}
        except requests.exceptions.RequestException as e:
            return {"success": False, "error": str(e)}

    def add_subscriber(
        self,
        email: str,
        list_ids: List[int],
        attributes: Dict[str, str] = None
    ) -> Dict[str, any]:
        """
        Add or update a contact in Brevo.

        Args:
            email: Contact email address
            list_ids: List of Brevo list IDs to add contact to
            attributes: Custom attributes (firstName, lastName, etc.)

        Returns:
            API response
        """
        url = f"{self.base_url}/contacts"

        payload = {
            "email": email,
            "listIds": list_ids,
            "updateEnabled": True
        }

        if attributes:
            payload["attributes"] = attributes

        try:
            response = requests.post(url, json=payload, headers=self.headers)
            if response.status_code in [201, 204]:
                return {"success": True, "message": "Contact added/updated"}
            else:
                return {"success": False, "error": response.text}
        except requests.exceptions.RequestException as e:
            return {"success": False, "error": str(e)}

# Example usage:
# api = BrevoEmailAPI("your-api-key-here")

# Send welcome email
# result = api.send_email(
#     to_email="customer@example.com",
#     to_name="Jane Doe",
#     subject="Welcome to Our Platform!",
#     html_content="<h1>Welcome!</h1><p>Thanks for signing up.</p>"
# )
# print(result)

# Add subscriber to list
# result = api.add_subscriber(
#     email="customer@example.com",
#     list_ids=[2],  # Your Brevo list ID
#     attributes={"FIRSTNAME": "Jane", "LASTNAME": "Doe"}
# )
# print(result)

from dataclasses import dataclass
from typing import List, Dict
from datetime import datetime

@dataclass
class CampaignMetrics:
    """Email campaign performance data."""
    campaign_name: str
    sent: int
    opens: int
    clicks: int
    conversions: int
    revenue: float
    cost: float

def calculate_email_roi(
    campaigns: List[CampaignMetrics]
) -> Dict[str, any]:
    """
    Calculate comprehensive email marketing ROI.

    Args:
        campaigns: List of campaign performance data

    Returns:
        Aggregated ROI metrics
    """
    try:
        total_sent = sum(c.sent for c in campaigns)
        total_opens = sum(c.opens for c in campaigns)
        total_clicks = sum(c.clicks for c in campaigns)
        total_conversions = sum(c.conversions for c in campaigns)
        total_revenue = sum(c.revenue for c in campaigns)
        total_cost = sum(c.cost for c in campaigns)

        # Calculate rates
        open_rate = (total_opens / total_sent * 100) if total_sent > 0 else 0
        click_rate = (total_clicks / total_opens * 100) if total_opens > 0 else 0
        conversion_rate = (total_conversions / total_clicks * 100) if total_clicks > 0 else 0

        # Calculate ROI
        net_profit = total_revenue - total_cost
        roi_ratio = total_revenue / total_cost if total_cost > 0 else 0
        roi_percentage = ((total_revenue - total_cost) / total_cost * 100) if total_cost > 0 else 0

        return {
            'total_emails_sent': total_sent,
            'open_rate': round(open_rate, 2),
            'click_through_rate': round(click_rate, 2),
            'conversion_rate': round(conversion_rate, 2),
            'total_revenue': round(total_revenue, 2),
            'total_cost': round(total_cost, 2),
            'net_profit': round(net_profit, 2),
            'roi_ratio': round(roi_ratio, 2),
            'roi_percentage': round(roi_percentage, 1),
            'revenue_per_email': round(total_revenue / total_sent, 4) if total_sent > 0 else 0
        }
    except Exception as e:
        print(f"Error calculating ROI: {e}")
        return {}

# Example: 3 months of email campaigns
campaigns = [
    CampaignMetrics('Welcome Series', 450, 203, 67, 12, 1800, 45),
    CampaignMetrics('Product Launch', 1200, 456, 98, 23, 4600, 120),
    CampaignMetrics('Weekly Newsletter', 3200, 992, 184, 31, 3720, 280),
    CampaignMetrics('Abandoned Cart', 890, 401, 156, 45, 6750, 89),
    CampaignMetrics('Re-engagement', 1100, 264, 41, 8, 960, 110),
]

roi_results = calculate_email_roi(campaigns)

print("Email Marketing Performance (3 Months)")
print("=" * 60)
print(f"Total emails sent: {roi_results['total_emails_sent']:,}")
print(f"Open rate: {roi_results['open_rate']}%")
print(f"Click-through rate: {roi_results['click_through_rate']}%")
print(f"Conversion rate: {roi_results['conversion_rate']}%")
print(f"\nFinancial Performance:")
print(f"Total revenue: ${roi_results['total_revenue']:,.2f}")
print(f"Total cost: ${roi_results['total_cost']:,.2f}")
print(f"Net profit: ${roi_results['net_profit']:,.2f}")
print(f"ROI: ${roi_results['roi_ratio']:.2f} for every $1 spent ({roi_results['roi_percentage']}%)")
print(f"Revenue per email: ${roi_results['revenue_per_email']}")

# Output:
# Email Marketing Performance (3 Months)
# ============================================================
# Total emails sent: 6,840
# Open rate: 35.67%
# Click-through rate: 22.34%
# Conversion rate: 21.84%
#
# Financial Performance:
# Total revenue: $17,830.00
# Total cost: $644.00
# Net profit: $17,186.00
# ROI: $27.68 for every $1 spent (2668.9%)
# Revenue per email: $2.6062