Sending Email with Attachment

Last updated:2026-01-16 10:44:02
Sending Email with Attachment
Last updated: 2026-01-16 10:44:02
The method of sending an email with an attachment through SMTP is to construct the content of a MIME-formatted email.
Email MIME Format
For more information, see MIME Protocol.
Note: 
A MIME message consists of two parts: email header and email body.
Email Header
The email header contains important information such as sender, recipient, subject, time, MIME version, and body type.
Note: 
Each piece of information is called a field, which consists of a domain followed by ":" and the information content and can be in one or multiple lines.
The first line of a field must be written "to the left", i.e., without whitespace characters (spaces and tabs) on the left.
The next lines must start with whitespace characters, one of which must not be inherent in the message itself (that is, it needs to be filtered out during decoding).
Blank lines are not allowed in the email header. If the first line is blank, some emails cannot be recognized by certain email client software, and the original code is displayed.
For example:
Content      
Example   
Date
Mon, 29 Jun 2009 18:39:03 +0800
From
abc@123.com
To
abc1@123.com
BCC
abc3@123.com
Subject
test
Message-ID
123@123.com
Mime-Version
1.0
Field      
Description   
Bcc
Blind carbon copy address
Cc
Copy address
Content-Transfer-Encoding
Content transfer encoding method
Content-Type
Content type
Date
Date and time
Delivered-To
Recipient address
From
Sender address
Message-ID
Message ID
MIME-Version
MIME version
Received
Transfer path
Reply-To
Reply-to address
Return-Path
Reply-to address
Subject
Subject
To
Recipient address
Email Body
Field      
Description   
Content-ID
Content ID
Content-Transfer-Encoding
Content transfer encoding method
Content-Location
Content location (path)
Content-Base
Content base location
Content-Disposition
Content disposition method
Content-Type
Content type
Some fields have parameters in addition to values. Value and parameter as well as parameter and parameter are separated with ";". Parameter name and parameter value are separated with "=".
The email body contains the content of the email, whose type is indicated by the Content-Type field in the email header.
Note: 
Common simple types include:
text/plain (plain text) 
text/html (hypertext)
The multipart type is the essence of MIME emails. The email body is divided into multiple parts, each of which consists of part header and part body separated by a blank line.
There are three common multipart types:
multipart/mixed
multipart/related
multipart/alternative
The meaning and use of each of these types can be seen from their names. The hierarchical relationship between them can be summarized as shown below:
﻿
﻿
﻿
If you want to add attachments to an email, you must define the multipart/mixed part. If there are embedded resources, you must define at least the multipart/related part; if plain text and hypertext coexist, you must define at least the multipart/alternative part.
Note: 
The number of attachments should not exceed 10, the size of a single attachment should not exceed 4 MB, and the total size of all attachments should not exceed 8 MB. For more information, see Data Structure.
Sample Go Code
package main
import (
    "bytes"
    "crypto/tls"
    "encoding/base64"
    "fmt"
    "io/ioutil"
    "log"
    "mime"
    "net"
    "net/smtp"
    "time"
)
﻿
// Test465Attachment  for port 465
func Test465Attachment() error {
    boundary := "GoBoundary"
    host := "sg-smtp.qcloudmail.com"
    port := 465
    email := "abc@cd.com"
    password := "***"
    toEmail := "test@test123.com"
    header := make(map[string]string)
    header["From"] = "test " + "<" + email + ">"
    header["To"] = toEmail
    header["Subject"] = "Test465Attachment"
    header["Content-Type"] = "multipart/mixed;boundary=" + boundary
    // This field is not used for the time being. Pass in `1.0` by default
    header["Mime-Version"] = "1.0"
    // This field is not used for the time being
    header["Date"] = time.Now().String()
    bodyHtml := "<!DOCTYPE html>\\n<html>\\n<head>\\n<meta charset=\\"utf-8\\">\\n<title>hello world</title>\\n</head>\\n<body>\\n " +
        "<h1>My first heading</h1>\\n    <p>My first paragraph.</p>\\n</body>\\n</html>"
    message := ""
    for k, v := range header {
        message += fmt.Sprintf("%s: %s\\r\\n", k, v)
    }
    buffer := bytes.NewBuffer(nil)
    buffer.WriteString(message)
    
    contentType := "Content-Type: text/html" + "; charset=UTF-8"
	body := "\\r\\n--" + boundary + "\\r\\n"
	body += contentType + "\\r\\n"
	body += "Content-Transfer-Encoding: base64\\r\\n"
	body += "\\r\\n" + base64.StdEncoding.EncodeToString([]byte(bodyHtml)) + "\\r\\n"
﻿
﻿
    attachment := "\\r\\n--" + boundary + "\\r\\n"
    attachment += "Content-Transfer-Encoding:base64\\r\\n"
    attachment += "Content-Disposition:attachment\\r\\n"
    attachment += "Content-Type:" + "application/octet-stream" + ";name=\\"" + mime.BEncoding.Encode("UTF-8",
        "./go.mod") + "\\"\\r\\n"
    buffer.WriteString(attachment)
    writeFile(buffer, "./go.mod")
    // Multiple attachments can be spliced at the end. There can be 10 attachments at most, each of which cannot exceed 5 MB in size. The TOTAL size of all attachments cannot exceed 8–9 MB; otherwise, EOF will be returned
    attachment1 := "\\r\\n--" + boundary + "\\r\\n"
    attachment1 += "Content-Transfer-Encoding:base64\\r\\n"
    attachment1 += "Content-Disposition:attachment\\r\\n"
    attachment1 += "Content-Type:" + "application/octet-stream" + ";name=\\"" + mime.BEncoding.Encode("UTF-8",
        "./bbbb.txt") + "\\"\\r\\n"
    buffer.WriteString(attachment1)
    writeFile(buffer, "./bbbb.txt")
    defer func() {
        if err := recover(); err != nil {
            log.Fatalln(err)
        }
    }()
﻿
    buffer.WriteString("\\r\\n--" + boundary + "--")
    message += "\\r\\n" + body
    auth := smtp.PlainAuth(
        "",
        email,
        password,
        host,
    )
    err := SendMailWithTLS(
        fmt.Sprintf("%s:%d", host, port),
        auth,
        email,
        []string{toEmail},
        buffer.Bytes(),
    )
    if err != nil {
        fmt.Println("Send email error:", err)
    } else {
        fmt.Println("Send mail success!")
    }
    return err
}
﻿
// Dial return a smtp client
func Dial(addr string) (*smtp.Client, error) {
    conn, err := tls.Dial("tcp", addr, nil)
    if err != nil {
        log.Println("tls.Dial Error:", err)
        return nil, err
    }
﻿
    host, _, _ := net.SplitHostPort(addr)
    return smtp.NewClient(conn, host)
}
﻿
// SendMailWithTLS send email with tls
func SendMailWithTLS(addr string, auth smtp.Auth, from string,
    to []string, msg []byte) (err error) {
    //create smtp client
    c, err := Dial(addr)
    if err != nil {
        log.Println("Create smtp client error:", err)
        return err
    }
    defer c.Close()
    if auth != nil {
        if ok, _ := c.Extension("AUTH"); ok {
            if err = c.Auth(auth); err != nil {
                log.Println("Error during AUTH", err)
                return err
            }
        }
    }
    if err = c.Mail(from); err != nil {
        return err
    }
    for _, addr := range to {
        if err = c.Rcpt(addr); err != nil {
            return err
        }
    }
    w, err := c.Data()
    if err != nil {
        return err
    }
    _, err = w.Write(msg)
    if err != nil {
        return err
    }
    err = w.Close()
    if err != nil {
        return err
    }
    return c.Quit()
}
﻿
// writeFile read file to buffer
func writeFile(buffer *bytes.Buffer, fileName string) {
    file, err := ioutil.ReadFile(fileName)
    if err != nil {
        panic(err.Error())
    }
    payload := make([]byte, base64.StdEncoding.EncodedLen(len(file)))
    base64.StdEncoding.Encode(payload, file)
    buffer.WriteString("\\r\\n")
    for index, line := 0, len(payload); index < line; index++ {
        buffer.WriteByte(payload[index])
        if (index+1)%76 == 0 {
            buffer.WriteString("\\r\\n")
        }
    }
}
﻿
func main() {
    Test465Attachment()
}
﻿
Sample Python Code
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import smtplib
import os
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders
from email.utils import formatdate
from email.header import Header
import ssl
﻿
def send_email_with_attachments():
    host = "smtp.qcloudmail.com"   
    port = 465
    email = "abc@cd.com"
    password = "****"
    to_email = "test@test123.com"
    
    msg = MIMEMultipart('mixed')
    msg['From'] = f"test <{email}>"
    msg['To'] = to_email
    msg['Subject'] = "Test465Attachment"
    msg['Date'] = formatdate(localtime=True)
    msg['Mime-Version'] = "1.0"
    
    html_body = """
    <!DOCTYPE html>
    <html>
    <head>
      <meta charset="utf-8"><title>hello world</title>
    </head>
    <body>
      <h1>my first head</h1>
      <p>my first paragraph</p>
    </body>
    </html>
    """
    
    # add HTML
    html_part = MIMEText(html_body, 'html', 'utf-8')
    msg.attach(html_part)
    
    # add attachment
    attachments = ["./name.txt"]
    
    for attachment_path in attachments:
        if os.path.exists(attachment_path):
            try:
                with open(attachment_path, 'rb') as file:
                    attachment_data = file.read()
                
                attachment_part = MIMEBase('application', 'octet-stream')
                attachment_part.set_payload(attachment_data)
                
                encoders.encode_base64(attachment_part)
                
                filename = os.path.basename(attachment_path)
                encoded_filename = Header(filename, 'utf-8').encode()
                attachment_part.add_header(
                    'Content-Disposition', 
                    f'attachment; filename="{encoded_filename}"'
                )
                
                msg.attach(attachment_part)
                print(f"add attachment successfully: {filename}")
                
            except Exception as e:
                print(f"add attachment {attachment_path} error: {e}")
        else:
            print(f"attachment missing: {attachment_path}")
    
    try:
        context = ssl.create_default_context()
        
        with smtplib.SMTP_SSL(host, port, context=context) as server:
            server.login(email, password)
            server.send_message(msg)
            print("send email success")
            return True
            
    except Exception as e:
        print(f"send email error: {e}")
        return False
﻿
﻿
if __name__ == "__main__":
    print("start sending email with attachment...")
    send_email_with_attachments()
﻿
Was this page helpful?
You can also Contact Sales or Submit a Ticket for help.
Yes
Feedback
Content	Example
Date	Mon, 29 Jun 2009 18:39:03 +0800
From	abc@123.com
To	abc1@123.com
BCC	abc3@123.com
Subject	test
Message-ID	123@123.com
Mime-Version	1.0
Field	Description
Bcc	Blind carbon copy address
Cc	Copy address
Content-Transfer-Encoding	Content transfer encoding method
Content-Type	Content type
Date	Date and time
Delivered-To	Recipient address
From	Sender address
Message-ID	Message ID
MIME-Version	MIME version
Received	Transfer path
Reply-To	Reply-to address
Return-Path	Reply-to address
Subject	Subject
To	Recipient address
Field	Description
Content-ID	Content ID
Content-Transfer-Encoding	Content transfer encoding method
Content-Location	Content location (path)
Content-Base	Content base location
Content-Disposition	Content disposition method
Content-Type	Content type
tencent cloud

Email MIME Format

Email Header

Email Body

Sample Go Code

Sample Python Code
