Sending Emails From Raspberry Pi Using Python (yagmail)

In this guide, we will learn how to send emails from a Raspberry Pi using a Gmail account and the Python library yagmail. This is incredibly useful for IoT projects, such as sending alerts when a sensor triggers or sending daily logs.

Prerequisites: Google Account Configuration

Before writing any code, we need to prepare the Gmail account that the Raspberry Pi will use to send messages.

Security Note: Google no longer allows "Less Secure Apps" to sign in using just your normal password. You must use an App Password.

Steps to Generate an App Password:

1. Log in to the Google Account you want to use on your Raspberry Pi.

2. Go to Google Account Security Settings.

3. Under the "Signing in to Google" section, ensure 2-Step Verification is turned ON. (App Passwords will not appear unless 2FA is enabled).

4. Once 2FA is on, look for App Passwords (you may need to use the search bar at the top of the settings page).

5. Create a new App Password:

   • App name: "Raspberry Pi" (or whatever you prefer).

   • Click Create.

6. Google will generate a 16-character code (e.g., abcd efgh ijkl mnop). Copy this code immediately. You will not see it again. This is the "password" you will use in your Python script.

Install Yagmail

yagmail (Yet Another GMAIL/SMTP client) makes sending emails much simpler than using Python's built-in smtplib.

Open your Raspberry Pi’s terminal and run:

sudo pip3 install yagmail

Note on OAuth2: If you plan to use the more complex OAuth2 authentication method instead of App Passwords, install the extra requirements:

pip3 install yagmail[oauth]

For this tutorial, we will stick to the simpler App Password method.

Step 1: the Simplest Possible Script

Now we will write a basic script to test if the connection works.

⚠ Security Warning: Hardcoding credentials (writing your password directly in the file) is insecure, especially if you share your code online. We are doing it here only for a quick test. In a production environment, you should use a separate secrets file or environment variables.

Create a file named send_email_simple.py:

nano send_email_simple.py

Paste the following code:

#!/usr/bin/env python3
import yagmail

# --- Configuration ---
# Your email address
my_gmail = "your_gmail@gmail.com"

# The 16-character App Password you generated in Step 1
# (Do not use your regular Gmail password)
my_password = "xxxx xxxx xxxx xxxx"

# The person receiving the email
recipient = "recipient@example.com"

# --- Sending the Email ---
try:
    # Initialize the connection
    yag = yagmail.SMTP(user=my_gmail, password=my_password)

    # Send the email
    yag.send(
        to=recipient,
        subject="Test Email from Raspberry Pi",
        contents="Hello! This is a test email sent successfully using Yagmail on Raspberry Pi."
    )
    print("✅ Email sent successfully!")

except Exception as e:
    print(f"❌ Error sending email: {e}")

Running the Script

Save the file (if using nano, press CTRL+X, then Y, then Enter) and run it:

python3 send_email_simple.py

If everything is configured correctly, you should see "Email sent successfully!" in your terminal, and the recipient should receive the email shortly.

Step 2: Storing Your Password Securely

Now that we have confirmed the basics work, let's make it secure. We shouldn't leave passwords sitting in our code files.

Option A: Using a Local File

1. Create a hidden file for the password so it's not visible in directory listings:

   echo "my_app_password_or_secret" > /home/pi/.local/share/.email_password
   # Restrict permissions so only the file owner can read it
   chmod 600 /home/pi/.local/share/.email_password

2. Update your script to read from this file:

   #!/usr/bin/env python3
   
   import yagmail
   
   # Read password from the secure file
   with open("/home/pi/.local/share/.email_password", "r") as f:
       password = f.read().strip()
   
   my_gmail = "your_gmail@gmail.com"
   recipient = "recipient@example.com"
   
   try:
       yag = yagmail.SMTP(user=my_gmail, password=password)
       yag.send(
           to=recipient,
           subject="Test Email (Password from File)",
           contents="Now I'm reading my password from a local file!"
       )
       print("✅ Email sent!")
   except Exception as e:
       print(f"❌ Error: {e}")

Option B: Using Environment Variables

1. Edit your bash profile (~/.bashrc or ~/.profile):

   nano ~/.bashrc

2. Add this line to the bottom:

   export GMAIL_APP_PASSWORD="my_app_password_or_secret"

3. Save, exit, and reload your profile:

   source ~/.bashrc

4. In Python, use os.environ to get the password:

   import os
   import yagmail
   
   # Get password from environment variable
   password = os.environ.get("GMAIL_APP_PASSWORD")
   
   if not password:
       print("Error: Password environment variable not found.")
       exit(1)
   
   my_gmail = "your_gmail@gmail.com"
   recipient = "recipient@example.com"
   
   yag = yagmail.SMTP(my_gmail, password)
   yag.send(
       to=recipient,
       subject="Password from Environment Variable",
       contents="Secure approach: reading the password from env vars!"
   )
   print("Email sent!")

Adding Attachments and Html (yagmail)

One of the best features of yagmail is how easy it makes sending attachments (like log files or photos) and HTML content.

Here is a complete example:

#!/usr/bin/env python3

import yagmail

def send_email_with_attachment(gmail_user, gmail_password, recipient, filepath):
    yag = yagmail.SMTP(gmail_user, gmail_password)

    # List items can be text, file paths, or HTML strings
    # Yagmail automatically detects if a string is a file path
    contents = [
        "Hello, here's an attachment:",
        filepath,
        "<b>This is some HTML content in bold!</b>",
        "<p>You can format this however you like.</p>"
    ]

    try:
        yag.send(
            to=recipient,
            subject="Email with Attachment and HTML",
            contents=contents
        )
        print("✅ Email sent with attachment and HTML!")
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == "__main__":
    # Example usage
    gmail_address = "your_gmail@gmail.com"

    # Use your preferred method for getting the password here
    # For simplicity in this snippet, we assume a variable
    gmail_password = "your_app_password"

    recipient = "recipient@example.com"

    # Make sure this file actually exists!
    file_to_attach = "/home/pi/test.txt"

    send_email_with_attachment(gmail_address, gmail_password, recipient, file_to_attach)

Under the hood, Yagmail automatically constructs a MIME email with multiple parts (text, HTML, attachments), saving you from writing dozens of lines of complex boilerplate code.

Using Oauth2 Instead of an App Password

While App Passwords are easy, OAuth2 is the industry standard for secure authentication.

6.1 Why Oauth2?

• No password stored: OAuth2 tokens replace your password in the code.

• Granular permissions: You grant access only for sending email, without exposing your full account password.

• Revocable: You can revoke OAuth2 credentials at any time without changing your real password.

6.2 Setting Up Oauth2 with Yagmail

Yagmail supports OAuth2 flows via the yagmail[oauth] extras:

1. Install with OAuth2 extras:

   pip3 install yagmail[oauth]

2. Register your email with Yagmail to generate an OAuth2 token:

   import yagmail
   
   # The first time, you may need to authorize via a browser window
   # You will typically need a 'client_secret.json' from Google Cloud Console
   yagmail.register('your_gmail@gmail.com', oauth2_file='~/oauth2_creds.json')

   This command-line or script process may prompt you to visit a link in your browser to grant permission. Once complete, your token is saved locally (in oauth2_creds.json).

Alternatively: If you have a Google Cloud project with OAuth2 credentials (Client ID & Secret), you can specify them. See Yagmail docs or google-auth-oauthlib docs for advanced details.

6.3 Example Code

After registering, you can use OAuth2 automatically:

#!/usr/bin/env python3

import yagmail

def send_oauth2_email():
    # No password needed here if you have the token file
    yag = yagmail.SMTP(
        user="your_gmail@gmail.com",
        oauth2_file="~/oauth2_creds.json"
    )
    yag.send(
        to="recipient@example.com",
        subject="Hello via OAuth2",
        contents="This message is sent with OAuth2. No stored password!"
    )
    print("Email sent via OAuth2!")

if __name__ == "__main__":
    send_oauth2_email()

Explanation:

• Once oauth2_creds.json is set up, Yagmail uses it to generate a valid OAuth2 token for sending Gmail.

• If the token expires or is invalid, Yagmail will help you refresh or reauthorize.

What is Mime?

MIME stands for Multipurpose Internet Mail Extensions. It is an internet standard that extends the format of email to support:

• Multiple parts: text, HTML, images, audio, video, and other application programs.

• Non-ASCII text: Using characters sets other than ASCII.

• Headers: describing content type and encoding.

When you use yagmail, it automatically handles all the complex MIME structuring for you. It detects if you are sending a file or a string, and packages it into the correct MIME type. However, sometimes you might want full control or need to avoid external libraries like Yagmail. In those cases, you must build the MIME structure manually.

Optional: Manual Mime with smtplib

For advanced usage, debugging, or if you simply prefer using Python's standard library without installing yagmail, you can manually create MIME messages. This requires more code but gives you total control.

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

# --- Configuration ---
sender = "your_gmail@gmail.com"
receiver = "recipient@example.com"
password = "YOUR_APP_PASSWORD" # Or load from file/env

subject = "Manual MIME Example"
body_text = "Hi, this email is built using MIMEMultipart and MIMEText."
body_html = """
<html>
  <body>
    <p>Hi,<br>
       This email is built using <b>MIMEMultipart</b> and <b>MIMEText</b>.<br>
       It has both plain text and HTML parts!
    </p>
  </body>
</html>
"""

# --- Create the MIME Object ---
msg = MIMEMultipart("alternative")
msg["From"] = sender
msg["To"] = receiver
msg["Subject"] = subject

# Attach parts into message container.
# According to RFC 2046, the last part of a multipart message, in this case
# the HTML message, is best and preferred.
part1 = MIMEText(body_text, "plain")
part2 = MIMEText(body_html, "html")

msg.attach(part1)
msg.attach(part2)

# --- Send the Email ---
context = ssl.create_default_context()
try:
    with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
        server.login(sender, password)
        server.sendmail(sender, receiver, msg.as_string())
    print("✅ Email sent via smtplib!")
except Exception as e:
    print(f"❌ Error: {e}")

This script demonstrates how to send a "multipart/alternative" email, which includes both a plain text version and an HTML version. Email clients will choose the best version to display.

Next Steps & Additional Tips

1. Multiple Recipients

   • Pass a list to the to argument: yag.send(to=["first@example.com", "second@example.com"], ...).

2. HTML Emails

   • Use an HTML string in contents: "<h1>Title</h1><p>Paragraph</p>".

3. File Permissions

   • Keep your local .email_password or oauth2_creds.json file secure using chmod 600.

4. Error Handling

   • Wrap your sending code in try-except blocks to handle timeouts or credential errors gracefully.

5. Other SMTP Providers

   • Adjust server and port accordingly. For example, smtp.office365.com for Outlook with port 587.

6. Revoking OAuth2

   • If necessary, revoke access in your Google Account Security settings.

References

• Yagmail GitHub:

  https://github.com/kootenpv/yagmail

• Gmail SMTP Settings:

  https://support.google.com/mail/answer/7126229

• App Passwords & 2FA:

  https://support.google.com/accounts/answer/185833

• Google OAuth2 with Python:

  https://google-auth.readthedocs.io/en/stable/

• Python smtplib Docs:

  https://docs.python.org/3/library/smtplib.html