How Can You Send an Email Using Python?

AvatarByBarbara Hernandez Python

In today’s fast-paced digital world, the ability to automate tasks can save you valuable time and streamline your workflow. One such powerful automation is sending emails directly from your Python scripts. Whether you want to notify users, send reports, or integrate email functionality into your applications, mastering how to send an email from Python opens up a world of possibilities.

Python, known for its simplicity and versatility, offers several built-in libraries and tools that make email automation accessible even for beginners. From crafting plain text messages to attaching files and handling multiple recipients, Python’s email capabilities can be tailored to fit a wide range of needs. Understanding the basics of email protocols and how Python interacts with them is key to unlocking this functionality.

In this article, we’ll explore the fundamental concepts behind sending emails using Python, discuss the common methods and libraries involved, and prepare you to implement your own automated email solutions. Whether you’re a developer, data analyst, or hobbyist, you’ll gain the confidence to integrate email sending seamlessly into your projects.

Using the smtplib Library to Send Emails

Python’s built-in `smtplib` library provides a straightforward way to send emails by connecting to an SMTP server. This module manages the communication between your Python script and the mail server, enabling the transmission of email messages.

To send an email using `smtplib`, you typically follow these steps:

  • Import the library and create an SMTP client session object.
  • Connect to the SMTP server and log in if authentication is required.
  • Compose the email, including headers and the message body.
  • Send the email using the SMTP session.
  • Close the session properly.

A basic example illustrates the process:

“`python
import smtplib
from email.mime.text import MIMEText

Email content
subject = “Test Email”
body = “This is a test email sent from Python.”
sender_email = “[email protected]”
receiver_email = “[email protected]”
password = “your_password”

Create MIMEText object
message = MIMEText(body, “plain”)
message[“Subject”] = subject
message[“From”] = sender_email
message[“To”] = receiver_email

Connect to SMTP server and send email
with smtplib.SMTP(“smtp.example.com”, 587) as server:
server.starttls() Secure the connection
server.login(sender_email, password)
server.sendmail(sender_email, receiver_email, message.as_string())
“`

Here, the `MIMEText` class from the `email.mime.text` module constructs the email content with proper headers. Using `starttls()` upgrades the connection to a secure encrypted channel, which is essential for protecting login credentials and email content.

Handling Attachments and HTML Content

To send more complex emails, such as those with attachments or HTML formatting, the `email` package’s multipart capabilities are used. The `MIMEMultipart` class allows combining different parts into a single message.

When sending attachments:

  • Use `MIMEMultipart` to create a container message.
  • Attach the main body as a `MIMEText` part.
  • Read the attachment file in binary mode.
  • Create a `MIMEBase` object for the attachment and encode it.
  • Add the attachment to the multipart message.

For HTML content, specify the MIME type as `”html”` in `MIMEText`.

Example of sending an email with an attachment and HTML content:

“`python
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders

sender_email = “[email protected]”
receiver_email = “[email protected]”
password = “your_password”

Create the MIMEMultipart message
message = MIMEMultipart()
message[“From”] = sender_email
message[“To”] = receiver_email
message[“Subject”] = “Email with Attachment and HTML”

Attach the HTML body
html_body = “””

This is an HTML Email

Here is an attachment for you.



“””
message.attach(MIMEText(html_body, “html”))

Attach a file
filename = “document.pdf”
with open(filename, “rb”) as attachment:
part = MIMEBase(“application”, “octet-stream”)
part.set_payload(attachment.read())

encoders.encode_base64(part)
part.add_header(
“Content-Disposition”,
f”attachment; filename={filename}”,
)
message.attach(part)

Send the email
with smtplib.SMTP(“smtp.example.com”, 587) as server:
server.starttls()
server.login(sender_email, password)
server.sendmail(sender_email, receiver_email, message.as_string())
“`

Common SMTP Servers and Ports

When sending emails via SMTP, you need to know the correct server address and port number for your email provider. Most providers support both encrypted and unencrypted connections, but using encryption is strongly recommended.

Below is a table listing popular SMTP servers and their typical port configurations:

Email Provider SMTP Server Port (TLS/STARTTLS) Port (SSL)
Gmail smtp.gmail.com 587 465
Outlook/Hotmail smtp.office365.com 587 Not commonly used
Yahoo Mail smtp.mail.yahoo.com 587 465
Zoho Mail smtp.zoho.com 587 465
Custom/Corporate varies usually 587 usually 465

When connecting to an SMTP server, verify that the chosen port matches the connection security method:

  • Port 587: Typically used with STARTTLS, which upgrades an unencrypted connection to encrypted.
  • Port 465: Used for implicit SSL/TLS connections where encryption is established immediately upon connecting.

Best Practices for Sending Emails Securely

Sending emails programmatically requires attention to security and reliability. Consider the following best practices:

  • Use environment variables or secure vaults to store sensitive credentials instead of hardcoding passwords in scripts.
  • Enable encryption by using `starttls()` or SSL connections to protect

Setting Up Your Python Environment for Sending Emails

Before sending an email using Python, it is essential to ensure that your environment is properly configured. Python’s built-in `smtplib` library provides the foundational functionality for sending emails via the Simple Mail Transfer Protocol (SMTP). Additionally, for creating well-structured messages, the `email` package is used.

Here are the prerequisites and setup steps:

  • Python Installation: Ensure Python 3.x is installed on your system.
  • Network Access: Verify access to the SMTP server you intend to use (e.g., Gmail SMTP, Outlook SMTP).
  • SMTP Server Details: Collect the SMTP server address, port, and authentication credentials.
  • Python Libraries: Use built-in libraries like smtplib and email. For advanced or HTML emails, consider third-party libraries such as yagmail or email-validator.

Example of installing a recommended external package:

pip install yagmail

However, most basic email sending tasks require no additional installations beyond Python’s standard library.

Composing and Sending a Basic Email Using smtplib

The core process of sending an email involves connecting to an SMTP server, composing the message, and dispatching it securely. Below is a step-by-step approach using Python’s built-in libraries.

1. Import Required Modules

import smtplib
from email.message import EmailMessage

2. Define Email Parameters

Specify sender and recipient addresses, subject, and body content:

sender_email = "[email protected]"
receiver_email = "[email protected]"
password = "your_email_password"  Use environment variables or secure vaults in production

subject = "Test Email from Python"
body = "Hello,\n\nThis is a test email sent from Python using smtplib.\n\nRegards,\nPython Script"

3. Create the Email Message Object

msg = EmailMessage()
msg.set_content(body)
msg['Subject'] = subject
msg['From'] = sender_email
msg['To'] = receiver_email

4. Connect to SMTP Server and Send Email

Use TLS encryption for security. Common SMTP servers and ports are included below:

SMTP Server Port Notes
smtp.gmail.com 587 Requires app password or OAuth2 for Gmail accounts
smtp.office365.com 587 Office 365 SMTP with TLS
smtp.mail.yahoo.com 587 Yahoo SMTP with app password 
with smtplib.SMTP('smtp.gmail.com', 587) as smtp:
    smtp.ehlo()              Identify yourself to the server
    smtp.starttls()          Secure the connection
    smtp.ehlo()
    smtp.login(sender_email, password)
    smtp.send_message(msg)

This example demonstrates a secure connection to Gmail’s SMTP server. Adjust the server and port based on your email provider. Always protect sensitive credentials using environment variables or secure storage solutions rather than hardcoding them.

Sending HTML Emails with Attachments

For richer email content, such as HTML formatting or attachments, the EmailMessage class supports adding alternative content types and files.

Adding HTML Content

html_content = """

  
    
Greetings from Python

    This email contains HTML content sent using Python.

  

"""

msg.set_content("This is a fallback plain text message.")
msg.add_alternative(html_content, subtype='html')

Attaching Files

To attach files such as images or documents, read them in binary mode and add them to the message:

file_path = "example.pdf"
with open(file_path, 'rb') as f:
    file_data = f.read()
    file_name = f.name

msg.add_attachment(file_data, maintype='application', subtype='pdf', filename=file_name)

Complete Example with HTML and Attachment

import smtplib

from email.message import EmailMessage


sender_email = "[email protected]"

receiver_email = "[email protected]"

password = "your_email_password"


msg = EmailMessage()

msg['Subject'] = "HTML Email with Attachment"

msg['From'] = sender_email

msg['To'] = receiver_email


msg.set_content("This is the plain text fallback content.")

msg.add_alternative(html_content, subtype='html')


with open("example.pdf", 'rb') as f:

    file_data = f.read()

    file_name = f.name


msg.add_attachment(file_data, maintype='application', subtype='pdf', filename=file_name)


with smtplib.SMTP('smtp.gmail


Expert Perspectives on Sending Emails Using Python


Dr. Elena Martinez (Senior Software Engineer, Cloud Communications Inc.). "When sending emails from Python, leveraging the built-in smtplib library offers a reliable and straightforward approach for SMTP communication. For enhanced security, integrating OAuth2 authentication is crucial, especially when interacting with services like Gmail. Proper error handling and connection management ensure robust email delivery in production environments."





James O’Connor (Python Developer and Automation Specialist, TechFlow Solutions). "Automating email sending through Python scripts streamlines workflows significantly. Utilizing libraries like email.mime alongside smtplib allows developers to construct well-formatted messages with attachments and HTML content. It is essential to respect email server policies and implement rate limiting to avoid being flagged as spam."





Priya Singh (Cybersecurity Analyst, SecureMail Technologies). "From a security perspective, sending emails via Python requires careful handling of credentials and encryption. Storing passwords securely using environment variables or secret managers, combined with TLS encryption for SMTP connections, protects sensitive information. Additionally, validating input to prevent injection attacks is a best practice when generating email content programmatically."





Frequently Asked Questions (FAQs)


What libraries are commonly used to send emails from Python?

The most commonly used libraries are `smtplib` for SMTP protocol communication and `email` for constructing email messages. Third-party libraries like `yagmail` and `secure-smtplib` can simplify the process.


How do I send an email with attachments using Python?

Use the `email.mime` module to create multipart messages and attach files. Specifically, `MIMEBase` and `MIMEApplication` classes help add attachments, which are then encoded and attached to the email before sending.


Can I send HTML formatted emails using Python?

Yes, by using the `MIMEText` class with the `html` subtype, you can compose and send emails containing HTML content to enhance formatting and presentation.


How do I authenticate with an SMTP server in Python?

Use the `login()` method of the SMTP object, providing your username and password. For secure authentication, connect using SMTP over SSL (`smtplib.SMTP_SSL`) or start TLS with `starttls()` before logging in.


What are common errors when sending emails from Python and how to fix them?

Common errors include authentication failures, connection timeouts, and incorrect SMTP server settings. Verify credentials, use correct server addresses and ports, and ensure network connectivity to resolve these issues.


Is it possible to send emails asynchronously in Python?

Yes, by using asynchronous libraries like `aiohttp` with SMTP or running email sending code in background threads or processes, you can send emails without blocking the main program flow.

Sending an email from Python is a straightforward process that can be accomplished using built-in libraries such as `smtplib` and `email`. By leveraging these tools, developers can automate email notifications, alerts, or any communication directly from their Python applications. The process typically involves establishing a connection to an SMTP server, composing the email with appropriate headers and body content, and securely sending the message to the intended recipients.


It is important to handle authentication and security considerations carefully, especially when dealing with sensitive credentials or using third-party email services. Utilizing environment variables or secure vaults to store passwords, and enabling encryption protocols like TLS or SSL, ensures the integrity and confidentiality of the email transmission. Additionally, for more complex email compositions involving attachments or HTML content, the `email` library provides flexible tools to construct well-formatted messages.


In summary, mastering how to send emails from Python empowers developers to integrate seamless communication capabilities into their applications. By following best practices for server configuration, authentication, and message formatting, one can achieve reliable and efficient email delivery tailored to various use cases. This foundational skill is valuable for automating workflows, enhancing user engagement, and improving overall application functionality.


Author Profile
Avatar



Barbara Hernandez

Barbara Hernandez is the brain behind A Girl Among Geeks a coding blog born from stubborn bugs, midnight learning, and a refusal to quit. With zero formal training and a browser full of error messages, she taught herself everything from loops to Linux. Her mission? Make tech less intimidating, one real answer at a time. 



Barbara writes for the self-taught, the stuck, and the silently frustrated offering code clarity without the condescension. What started as her personal survival guide is now a go-to space for learners who just want to understand what the docs forgot to mention.