Language SDK

Stop debugging smtplib SSL errors

smtplib has confusing SSL/TLS modes, cryptic error messages, and no delivery confirmation. Ark's Python SDK sends email in 3 lines—no SMTP configuration, no blocked requests, no "email sent but never arrived" mystery.

26
MCP tools
Sub-second
Delivery
99.9%
Inbox rate
$0.50
Per 1K emails

Python's email stack is stuck in 2005

smtplib requires you to manage connections, figure out SMTP vs SMTP_SSL vs starttls(), and hope your email actually arrived. Django's send_mail blocks your views. Flask-Mail is barely maintained. FastAPI devs accidentally freeze their endpoints sending email synchronously.

  • ×smtplib: SSL vs TLS confusion, vague "Network unreachable" errors, no delivery confirmation
  • ×Django send_mail(): blocks request execution—need Celery just to send email
  • ×Flask-Mail: minimally maintained, no native support for modern email providers
  • ×FastAPI: naive implementations freeze endpoints during SMTP handshakes

HTTP API instead of SMTP

Ark sends email over HTTPS—no port 25/587 firewall issues, no SSL certificate headaches, no connection pooling. You get clear error messages, instant delivery confirmation, and async support built in.

3 lines of code to send—no SMTP configuration
Works on port 443 (HTTPS)—no firewall or VPS restrictions
Clear JSON error responses, not cryptic SMTP codes
Native async support for FastAPI without BackgroundTasks hacks
2 minutes

Replace smtplib in 2 minutes

pip install, set one environment variable, send. No SMTP host, port, TLS mode, or authentication dance.

1

Install the SDK

Works with Python 3.9+. Async support included.

pip install ark-email
2

Set your API key

Get your key from arkhq.io. One environment variable, no config files.

export ARK_API_KEY=ark_live_xxxxxx
3

Send email

Three lines. No SMTP connection management. Delivery confirmation in the response.

from ark import Ark

ark = Ark()  # Reads ARK_API_KEY from environment

response = ark.emails.send(
    from_="[email protected]",
    to="[email protected]",
    subject="Welcome!",
    html="<h1>You're in.</h1>",
)
print(response.id)  # Delivery confirmed

Code examples

Copy and paste to get started quickly.

Django (no Celery needed for simple cases)
# views.py
from ark import Ark
from django.conf import settings

ark = Ark(api_key=settings.ARK_API_KEY)

def signup(request):
    user = User.objects.create(email=request.POST["email"])

    # Ark is fast enough to call inline for simple cases
    # (sub-second response, non-blocking HTTP call)
    ark.emails.send(
        from_="[email protected]",
        to=user.email,
        subject="Welcome to YourApp",
        html=f"<h1>Hi {user.first_name}!</h1><p>Let's get started.</p>",
    )

    return JsonResponse({"status": "created"})

# For high-volume, still use Celery—but the email call itself is simple:
# @shared_task
# def send_email_task(to, subject, html):
#     ark.emails.send(from_="...", to=to, subject=subject, html=html)
FastAPI (proper async)
# main.py
from fastapi import FastAPI
from ark import AsyncArk  # Async client for FastAPI
import os

app = FastAPI()
ark = AsyncArk(api_key=os.environ["ARK_API_KEY"])

@app.post("/signup")
async def signup(email: str, name: str):
    # Actually async—doesn't block the event loop
    await ark.emails.send(
        from_="[email protected]",
        to=email,
        subject=f"Welcome, {name}!",
        html="<h1>You're in!</h1>",
    )
    return {"status": "success"}

# Compare to smtplib, which blocks the entire event loop:
# import smtplib  # ← This freezes your endpoint
Flask (simple and direct)
# app.py
from flask import Flask, request, jsonify
from ark import Ark

app = Flask(__name__)
ark = Ark()  # Reads ARK_API_KEY from environment

@app.post("/contact")
def contact():
    data = request.json

    ark.emails.send(
        from_="[email protected]",
        to="[email protected]",
        subject=f"Contact form: {data['subject']}",
        html=f"<p>From: {data['email']}</p><p>{data['message']}</p>",
        reply_to=data["email"],
    )

    return jsonify({"sent": True})

What you can build

Auth emails that don't block views

Verification, password reset, magic links. Ark's HTTP call is fast enough to run inline—no Celery overhead for simple cases.

FastAPI without async headaches

AsyncArk client is truly async. No frozen endpoints, no BackgroundTasks workaround, no smtplib blocking the event loop.

Django without Celery (for simple cases)

Ark responds in sub-second. For transactional emails, you often don't need a task queue. For bulk, still use Celery—but the call is simple.

Scripts and CLIs

No SMTP server configuration. pip install, set one env var, send. Works in any Python script.

Why developers choose Ark

No SMTP configuration

Forget EMAIL_HOST, EMAIL_PORT, EMAIL_USE_TLS vs EMAIL_USE_SSL. One API key, done.

Works behind firewalls

SMTP needs port 25/587/465. Ark uses HTTPS (port 443)—works on PythonAnywhere, Heroku, Docker, corporate networks.

Delivery confirmation

smtplib returns nothing useful. Ark returns message ID, status, and clear error messages if something fails.

True async for FastAPI

AsyncArk uses aiohttp under the hood. Doesn't block your event loop like smtplib does.

What you get with Ark

Automatic SPF, DKIM, DMARC
Real-time webhooks
Suppression management
Unlimited domains
Unlimited team members
$2.50 (5,000 emails) welcome credit
No monthly fees

Frequently asked questions

Why not just use smtplib?

smtplib works but requires managing SSL/TLS modes, connection pooling, authentication, and error handling manually. It gives no delivery confirmation—your email can fail silently. Ark handles all of this and tells you exactly what happened.

Does this work with Django's EMAIL_BACKEND?

You can use Ark alongside Django's email system, but we recommend using the SDK directly. It's cleaner: ark.emails.send() instead of configuring EMAIL_HOST, EMAIL_PORT, EMAIL_USE_TLS, etc.

Will this block my FastAPI endpoints?

No. Use AsyncArk for truly async email sending. Unlike smtplib (which blocks the event loop), Ark's async client is non-blocking.

What about Flask-Mail?

Flask-Mail is minimally maintained and only supports SMTP. Ark's SDK works in Flask with no extra setup—just import and send.

Do I still need Celery?

For bulk email or complex pipelines, yes. For transactional emails (verification, password reset), Ark is fast enough to call inline. No task queue overhead for simple cases.

What does it cost?

$0.50 per 1,000 emails. No monthly fees. $2.50 welcome credit (5,000 emails). Most Python apps run for months on the free credit.

pip install ark-email

No smtplib. No SSL confusion. No blocked requests. 2 minutes to your first email.