DEV Community: AxonCraft

How to Send 1000 Personalized Emails with 50 Lines of Python

AxonCraft — Thu, 19 Mar 2026 09:24:08 +0000

How to Send 1000 Personalized Emails with 50 Lines of Python

You have a list of 1,000 contacts and a message to send. You open Mailchimp, stare at the pricing page, and realize that for your use case — a one-off outreach campaign, a product launch, or a customer notification — you'd be paying $20–$100/month for a tool you'll use twice.

There's a better way.

Python's built-in smtplib library can send personalized emails to your entire list with no monthly fees, no subscriber limits, and complete control over every message. Here's how to do it in under 50 lines of code.

Why Skip Mailchimp (for This Use Case)

Mailchimp is a great product — but it's designed for marketing teams managing ongoing campaigns with templates, A/B tests, and analytics dashboards. If you're a developer or technical founder who needs to:

Send a one-time batch of personalized emails
Trigger emails programmatically from your app
Keep costs at zero for small/medium sends
Own your sending logic without vendor lock-in

...then Python + SMTP is the right tool.

The tradeoffs: you handle deliverability yourself (use Gmail, Zoho, or a transactional provider like SendGrid's free tier), and you won't get open-rate tracking out of the box. For most programmatic use cases, that's a perfectly fine trade.

What You Need

Python 3.x (no extra installs required — smtplib, csv, and email are all stdlib)
A Gmail account with App Passwords enabled (or any SMTP provider)
A CSV file with your recipient list

Your CSV should look like this:

name,email,company
Alice Chen,alice@example.com,Acme Corp
Bob Smith,bob@example.com,TechStart
Carol Wu,carol@example.com,BuildCo

Part 1: Basic SMTP Email Sender

Start with the core pattern — authenticate and send a single email:

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

SMTP_SERVER = "smtp.gmail.com"
SMTP_PORT   = 587
USERNAME    = "you@gmail.com"
PASSWORD    = "your-app-password"   # Use Gmail App Password, not your login password

def send_email(to_name: str, to_email: str, subject: str, body: str) -> None:
    msg = MIMEMultipart()
    msg["From"]    = USERNAME
    msg["To"]      = to_email
    msg["Subject"] = subject
    msg.attach(MIMEText(body, "plain"))

    with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
        server.starttls()                    # Upgrade to TLS
        server.login(USERNAME, PASSWORD)
        server.sendmail(USERNAME, to_email, msg.as_string())
        print(f"✅ Sent to {to_name} <{to_email}>")

That's it. This function handles the full SMTP handshake: connect → TLS → authenticate → send → close.

Part 2: Loop Through a CSV and Personalize Each Email

Now wire it to your contacts list:

import csv
import time

def send_bulk_emails(csv_path: str) -> None:
    subject = "A quick note from [Your Name]"

    with open(csv_path, newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)

        for row in reader:
            name    = row["name"]
            email   = row["email"]
            company = row["company"]

            # Personalize the message body per recipient
            body = f"""Hi {name},

I came across {company} and wanted to reach out personally.

[Your personalized message here]

Best,
[Your Name]
"""
            send_email(name, email, subject, body)
            time.sleep(1)   # Throttle: 1 email/second to avoid SMTP rate limits

send_bulk_emails("recipients.csv")

The time.sleep(1) is important — most SMTP providers rate-limit bulk sends. For 1,000 emails, this script runs in about 17 minutes unattended. Start it, go make coffee, come back to a done job.

Putting It All Together: The Full 50-Line Script

import smtplib, csv, time
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

SMTP_SERVER = "smtp.gmail.com"
SMTP_PORT   = 587
USERNAME    = "you@gmail.com"
PASSWORD    = "your-app-password"

def send_email(to_name, to_email, subject, body):
    msg = MIMEMultipart()
    msg["From"]    = USERNAME
    msg["To"]      = to_email
    msg["Subject"] = subject
    msg.attach(MIMEText(body, "plain"))
    with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:
        server.starttls()
        server.login(USERNAME, PASSWORD)
        server.sendmail(USERNAME, to_email, msg.as_string())

def send_bulk_emails(csv_path):
    subject = "Quick note for you"
    sent, failed = 0, 0
    with open(csv_path, newline="", encoding="utf-8") as f:
        for row in csv.DictReader(f):
            body = f"Hi {row['name']},\n\n[Your message here]\n\nBest,\n[Your Name]"
            try:
                send_email(row["name"], row["email"], subject, body)
                print(f"✅ {row['email']}")
                sent += 1
            except Exception as e:
                print(f"❌ {row['email']} — {e}")
                failed += 1
            time.sleep(1)
    print(f"\nDone: {sent} sent, {failed} failed")

send_bulk_emails("recipients.csv")

Under 50 lines. No dependencies. Runs anywhere Python runs.

Tips for Staying Out of Spam

Use a warmed-up address — don't blast 1,000 emails from a brand-new Gmail on day one
Personalize every email — identical body = spam filter magnet
Add an unsubscribe line — "Reply STOP to unsubscribe" is enough for small lists
Throttle your sends — 60–100/hour is safe for Gmail free accounts
Use Gmail App Passwords — never hardcode your real password; generate one at myaccount.google.com > Security > App Passwords

Want a Pre-Built Version with Error Handling, Logging & Retry?

If you'd rather skip the setup and get a production-ready script that includes:

Automatic retry on failed sends
Send log with timestamps
HTML email support
Progress bar for large lists

Check out the ready-to-run version here:

Python Email Automation Script — Bulk + Personalized

For $25, you get a complete tool you can run today — no Mailchimp account required.

Your list, your code, your control.

Stop Cleaning Spreadsheets by Hand — Automate It with Python

AxonCraft — Thu, 19 Mar 2026 09:23:18 +0000

Stop Cleaning Spreadsheets by Hand — Automate It with Python

You know the drill. It's Monday morning, someone dumps a 5,000-row Excel file on your desk, and now you're spending the next two hours hunting for duplicates, fixing date formats, and deleting rows where half the fields are blank. By the time you're done, it's lunch. And next week? Same thing.

Manual spreadsheet cleaning is one of those invisible time traps that developers and analysts accept as "just part of the job." It doesn't have to be.

Python's pandas library can automate virtually every repetitive cleaning task in minutes — and once you write the script, you'll never do it by hand again.

Why Manual Cleaning Is Costing You More Than You Think

When you clean data by hand, you're not just losing time — you're introducing risk. A misclick removes the wrong row. A find-and-replace corrupts a date column. You miss a subtle duplicate because two emails differ only by capitalization.

The real cost of manual cleaning:

Hours of repetitive work that add no analytical value
Human error that silently corrupts your results
No repeatability — next time, you start from scratch
No audit trail — nobody knows what was changed or why

Automation solves all four problems.

The Setup

You'll need pandas and openpyxl to read .xlsx files:

pip install pandas openpyxl

Now load your spreadsheet into a DataFrame:

import pandas as pd

# Load your Excel file
df = pd.read_excel('customer_data.xlsx')

# Quick preview
print(df.shape)       # (rows, columns)
print(df.dtypes)      # column types
print(df.isnull().sum())  # count missing values per column

This three-line audit tells you exactly what you're dealing with before you touch a single cell.

Cleaning #1: Handle Missing Values

Missing values are almost always present in real-world data. Here's how to deal with them programmatically:

import pandas as pd

df = pd.read_excel('customer_data.xlsx')

# Option A: Drop rows where ANY column is missing
df_clean = df.dropna()

# Option B: Drop rows only if key columns are missing
df_clean = df.dropna(subset=['customer_id', 'email'])

# Option C: Fill numeric columns with the column mean
df['revenue'].fillna(df['revenue'].mean(), inplace=True)

# Option D: Fill text columns with a placeholder
df['phone'].fillna('N/A', inplace=True)

print(f"Rows before: {len(df)} | Rows after: {len(df_clean)}")

Choose the strategy that makes sense for your data. For analytics, dropping incomplete rows is often safest. For reporting, filling with defaults keeps your row count consistent.

Cleaning #2: Remove Duplicates and Standardize Formats

Duplicates are sneaky — especially when they differ by whitespace or capitalization. Here's a full cleaning pipeline that handles duplicates, text standardization, and date parsing in one pass:

import pandas as pd

df = pd.read_excel('customer_data.xlsx')

# Normalize text columns: strip whitespace, lowercase
df['email'] = df['email'].str.strip().str.lower()
df['name']  = df['name'].str.strip().str.title()

# Remove exact duplicate rows based on key fields
before = len(df)
df = df.drop_duplicates(subset=['customer_id', 'email'], keep='first')
after  = len(df)
print(f"Duplicates removed: {before - after}")

# Standardize date column to consistent format
df['signup_date'] = pd.to_datetime(df['signup_date'], errors='coerce')
df['signup_date'] = df['signup_date'].dt.strftime('%Y-%m-%d')

# Save the cleaned file
df.to_excel('customer_data_cleaned.xlsx', index=False)
print("✅ Cleaned file saved.")

Run this script on any new export and your data is clean in seconds — every time, consistently, without touching Excel.

What You Just Automated

With about 25 lines of Python, you've replaced a process that used to take hours:

Task	Before	After
Find & remove duplicates	30+ minutes	2 seconds
Fix missing values	20+ minutes	2 seconds
Standardize text/dates	30+ minutes	2 seconds
Save clean output	5 minutes	automatic

The script is reusable, auditable, and error-free. You can run it in a cron job, trigger it from a web app, or chain it into a larger data pipeline.

Take It Further

If you want a ready-made Excel cleaning tool that handles edge cases, batch processing, multiple sheets, and outputs an audit report — without writing the boilerplate yourself — check out:

Excel Data Cleaner — Python Automation Script

It's a plug-and-play Python script built for data analysts and developers who need clean data fast. For $20, you get a production-ready cleaner you can drop into any project today.

Stop spending Monday mornings fighting spreadsheets. Let Python do it.

Stop Writing Messy Web Scrapers — A Clean Python Template That Actually Works

AxonCraft — Thu, 19 Mar 2026 09:15:21 +0000

Most web scraping tutorials give you 20 lines of spaghetti code that breaks the moment the website changes. Here's a better way.

The Problem

You search "Python web scraping tutorial", copy the code, and end up with something like this:

import requests
from bs4 import BeautifulSoup
r = requests.get("https://example.com")
soup = BeautifulSoup(r.content, 'html.parser')
data = soup.find_all('div', class_='product')
# ... 50 more lines of hardcoded mess

It works once. Then the URL changes. Or you need to scrape a different site. You rewrite everything from scratch.

The Fix: CONFIG-Based Template

The solution is simple: separate configuration from logic. Put everything that might change at the top, keep the functions clean.

# ─── CONFIG — change only this section ───
CONFIG = {
    'url': 'https://example.com',
    'output_file': 'results.csv',
    'timeout': 10,
    'headers': {
        'User-Agent': 'Mozilla/5.0 (compatible; MyBot/1.0)'
    }
}
# ─────────────────────────────────────────

def get_page(url):
    response = requests.get(url, headers=CONFIG['headers'], timeout=CONFIG['timeout'])
    response.raise_for_status()
    return BeautifulSoup(response.content, 'html.parser')

def extract_data(soup):
    title = soup.title.string.strip() if soup.title else "N/A"
    links = [a['href'] for a in soup.find_all('a', href=True)]
    text  = ' '.join(p.get_text(strip=True) for p in soup.find_all('p'))
    return {'title': title, 'links': ' | '.join(links), 'text': text[:500]}

def save_to_csv(data, path):
    import csv
    with open(path, 'w', newline='', encoding='utf-8') as f:
        writer = csv.DictWriter(f, fieldnames=data.keys())
        writer.writeheader()
        writer.writerow(data)

Why This Pattern Works

Change target URL → edit 1 line in CONFIG
Different output file → edit 1 line in CONFIG
Add rate limiting → add 'delay': 2 to CONFIG
Hand it to a teammate → they only need to read CONFIG

No hunting through 200 lines of code to find what to change.

Running It

pip install requests beautifulsoup4
python scraper.py

Output: a clean CSV with title, all links, and page text. Ready to open in Excel or feed into your next script.

What's Next

Once you have the base template, extending it is easy:

Add pagination: loop through page=1, page=2, etc. in CONFIG
Add error retries: wrap get_page() in a retry decorator
Add scheduling: use schedule library to run it daily

I packaged the complete version (with error handling, CSV output, retry logic, and full comments) as a ready-to-run script. If you want to skip the setup: grab the full template here — it's $15 and runs out of the box.

Otherwise, the pattern above is enough to get you started. Happy scraping.