Postmark
Dev Blog

Automate Python emails with attachments that get delivered

9 min read
  • Greg Svoboda

Some of the most important emails require attachments, such as receipts, order confirmations, contracts, or digital assets. You need those emails to arrive automatically and reliably when customers and partners expect them.

But attachments tend to increase bounce rates due to either security concerns, reduced engagement signals, or inbox provider policies, making deliverability harder to guarantee.

A few key practices help you get top-tier deliverability when email attachments really matter:

  • Follow general email guidelines
  • Understand where problems happen and how to spot them
  • Create processes that put best practices in motion
  • Automate to scale your success for a higher volume

Below, we’ll show you how to implement these practices in a Python application.

Why emails with attachments fail delivery

Email bounces happen for a host of reasons. If you send attachments and see bounces, those files are likely causing delivery failures.

Attachments pose security risks

Phishing and malware attacks often use attachments, so inbox providers scrutinize them closely:

  • Providers automatically block anything executable or compressed (e.g.,.7z,.rar,.exe). This policy often extends to.zip files.
  • Providers see red flags when you send unsolicited attachments, especially from new domains, even for “safe” file types like PDFs.

Attachments affect sender reputation

Recipients tend to avoid opening messages with unexpected attachments. Lower open rates, in turn, harm your domain reputation, making it even harder to deliver your emails.

Improving your deliverability starts with digging into exactly where you’re having problems. The first resource to consult is SMTP bounce messages.

Study your bounce messages

If your emails regularly bounce back, it’s fair to assume the underlying issue is the file attachments. You can find out more by examining the error reports.

The Postmark dashboard helps you make sense of errors. If you don’t have the tool set up, you can look into the bounce messages in your sending inbox.

This SMTP error message shows what you might see when an attachment causes an email to bounce:

Code
From: Mail Delivery System MAILER-DAEMON@recipient-isp.com To: sender@yourdomain.com Date: Wednesday, Apr 22, 2026, 3:28 PM Subject: Undeliverable: Project Files Update Delivery has failed to these recipients or groups: recipient@example.com Your message was rejected by the recipient's email system because it was flagged as a security risk or spam. Diagnostic information for administrators: Generating server: example.com recipient@example.com #554 5.7.1 Service unavailable; Message rejected: Attachment content triggered security policy (SPAM-FILTER-ATTACHMENT) ## Original message headers: Return-Path: sender@yourdomain.com Received: from yourdomain.com (192.168.1.100) by example.com (10.0.0.1) with Microsoft SMTP Server id 15.1.2507.35; Wed, 22 Apr 2026 15:27:55 -0700 Subject: Project Files Update MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="--boundary_12345" ----boundary_12345 Content-Type: application/x-zip-compressed; name="invoice_details.zip" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="invoice_details.zip"

At a high level, this report shows that the inbox provider flagged your email as a security risk. The specific SMTP error code 554 5.7.1 indicates that your attachment triggered the inbox security policy. The attached file is a .zip — compressed files are more likely to cause problems than some other attachment types.

Error code 554 often indicates a problem with attachments. Depending on the security policies your inbox providers use, you might see the following errors.

Different error codes can indicate the same problems — attachments that are too large or that raise security red flags due to content or file type.

Secure delivery for your attachments, every time

Are we suggesting you stop sending attachments? Of course not. After all, some attachments must be sent. So how do you ensure delivery on those critical files?

Let’s review best practices for sending automated attachments, then the basics of implementing them in a Python application.

Best practices for sending attachments

Regardless of what your bounce messages show, there are three hard rules:

  • Follow size limits: Inbox provider policies vary, so scope all your emails to the smallest allowed file sizes:
    • Keep TextBody and HtmlBody under 5 MB each.
    • Limit your total message size, including attachments, to 10 MB .
    • Be conservative with size limits, because encryption increases file size. A 15 MB attachment can easily grow to over 20 MB after base64 encoding.
  • Send only allowed file types:
    • PDFs are the most widely allowed file type.
    • Standard file types like.docx,.xlsx,.pptx,.csv,.txt,.rtf,.jpg,.png,.bmp,.mp3/4,.wav, and.eml are also widely allowed.
      • Note that older Microsoft Office filetypes (.doc, xls, ppt) are often flagged by many corporate email gateways or security tools.
    • Check your email API to see which attachment types they allow. Stricter limits help maintain deliverability.
  • Avoid red flags:

Best practices for attachments include “softer” guidelines, as well. You may need to adapt these, but following them closely improves delivery rates.

  • Send attachments sparingly. Only send information in an attachment when that’s truly the best format:
    • If the content fits in the email body without too much formatting, put it there. Use tested templates where possible.
    • Send event information in body text or a secure invitation link, as .ics files are a growing tool for phishing attacks.
    • Spam filters find it easier to parse embedded images, so opt for these over small.jpg or other image file attachments.
    • Reserve attachments for critical documents such as invoices, detailed receipts, and contracts, or for digital assets such as transparent image files.
  • Maintain a high sender reputation score for any mail server sending attachments. Use a dedicated server for transactional emails and send attachments from that domain:
    • Don’t send attachments to bulk mailing lists or from bulk email servers. Keep attachments out of marketing emails.
    • Only send attachments that recipients are highly likely to open. They won’t click on unsolicited attachments (and they shouldn’t!).
  • Use a file format that’s easy to open and hard to exploit. You need your attachments to be deliveredandopened to keep your reputation score high:
    • Use PDF files whenever possible. Standard document formats like.doc(x),.xls(s), and.ppt(x) are no less safe than PDFs, but PDFs are more deliverable:
      • Outdated inbox security policies may still treat PDFs as more secure than other document formats.
      • PDFs are a universal open standard, so all recipients can open them.
    • For image files, use.jpg or.png if you need transparency.
    • Avoid sending compressed files. If you must, use.zip.
  • Use secure links for larger or executable files. Transactional email recipients already have a relationship with you, so you can ask them to log in to access valuable files. Keep the most sensitive information out of email and store it where you have more control over access.

These guidelines help you deliver your most important files successfully. Next, we’ll show you the basics of how to do this in a Python application.

Use built-in Python libraries to send attachments

The code sample below shows the most basic way to send an email with an attachment. It uses two built-in Python modules to send a ready.pdf file.

TerminalCode
import smtplib from email.message import EmailMessage # Create the email msg = EmailMessage() msg['Subject'] = 'Receipt Attachment' msg['From'] = 'your_email@example.com' msg['To'] = 'recipient@sample.com' msg.set_content('Hello,\n\nThis is a test email with an attached receipt.\n') # Attach a file file_path = 'example_receipt.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) # Send the email via SMTP server smtp_server = 'smtp.example.com' smtp_port = 587 with smtplib.SMTP(smtp_server, smtp_port) as server: server.starttls() # Secure the connection server.login('your_email@example.com', 'your_password') server.send_message(msg) print("Email sent successfully!")

This code is a bare-bones way of sending email. You can integrate it into an automated workflow triggered by an application event.

Automate for efficiency and consistency

You already know that you should only send essential attachments automatically — receipts, invoices, and contracts, all documents your users expect.

The automatic trigger for these messages is user action in your application. In this scenario, human involvement can derail efficiency. Design, test, and monitor your process carefully, then let it run hands-off to ensure delivery.

Here’s a simple automation script that takes data from an in-application event to create an attachment and send an email:

TerminalCode
import smtplib from email.message import EmailMessage import os def generate_receipt(order): """Create a simple text receipt file.""" filename = f"receipt_{order['order_id']}.txt" with open(filename, 'w') as f: f.write(f"Order ID: {order['order_id']}\n") f.write(f"Customer: {order['customer_name']}\n") f.write(f"Email: {order['customer_email']}\n\n") f.write("Items:\n") total = 0 for item in order['items']: line_total = item['price'] * item['quantity'] total += line_total f.write(f"- {item['name']} (x{item['quantity']}): ${line_total:.2f}\n") f.write(f"\nTotal: ${total:.2f}\n") return filename def send_email_with_attachment(to_email, subject, body, reply_to, attachment_path): """Send email with attachment.""" msg = EmailMessage() msg['Subject'] = subject msg['From'] = 'your_email@example.com' msg['Reply-To'] = reply_to msg['To'] = to_email msg.set_content(body) # Attach file with open(attachment_path, 'rb') as f: file_data = f.read() file_name = os.path.basename(f.name) msg.add_attachment(file_data, maintype='application', subtype='octet-stream', filename=file_name) # Send email with smtplib.SMTP('smtp.example.com', 587) as server: server.starttls() server.login('your_email@example.com', 'your_password') server.send_message(msg) def process_purchase(order): """Simulates handling a completed purchase.""" print(f"Processing order {order['order_id']}...") # Step 1: Generate receipt receipt_file = generate_receipt(order) # Step 2: Send confirmation email subject = f"Your Order Confirmation #{order['order_id']}" body = f"""Hi {order['customer_name']}, Thank you for your purchase! Your order has been processed successfully. Please find your receipt attached. Best regards, Your Store Team """ send_email_with_attachment( order['customer_email'], subject, body, reply_to='orders@example.com', receipt_file ) # Optional: clean up the receipt file os.remove(receipt_file) print("Order processed and email sent.") # ---- Example usage (simulated purchase event) ---- if __name__ == "__main__": sample_order = { "order_id": "12345", "customer_name": "Jane Doe", "customer_email": "customer@sample.com", "items": [ {"name": "T-shirt", "price": 19.99, "quantity": 2}, {"name": "Hat", "price": 14.99, "quantity": 1} ] } # This simulates the trigger after a successful checkout/payment process_purchase(sample_order)

Automating receipt creation and message sending means you know exactly what you sent and when. This approach helps you avoid sending a bad file type, as attachments always go out from the same mail server.

In theory, this could create an attachment that’s too large, but it’s extremely unlikely. You could add a validation method to address that concern if your application calls for it.

Notice that the email uses a reply_to field in the header. It’s a good idea to set up an inbox for inbound customer emails. The mailbox you use for automated sending will receive a lot of SMTP reports and other automated messages, and no-reply addresses often set off spam filters.

One final adjustment can make your automated messages more efficient. Larger messages with attachments slow servers and delay delivery. Send attachments as a background job instead of sending messages synchronously in process_purchase. In production, use a third-party tool to handle message queues.

Next-level deliverability for Python email with Postmark

The best way to improve attachment deliverability is to use an email service with a strong track record. Postmark makes deliverability affordable and accessible, in part by maintaining completely separate services for transactional and bulk email.

In even better news for Python developers, Postmark recently introduced a new Python library. Simply import it into your application with the commands pip install postmark-python and import postmark.

The package gives you access to templates that help you reduce the number of attachments you send, and built-in checks to ensure the attachments and messages you do send are compatible with inbox security policies.