🤖 Teach your AI coding agent how to send email with Postmark Skills
Learn more
x
Sending bulk email in Python? Prioritize practices that get your mail delivered | Postmark
Email delivery

Sending bulk email in Python? Prioritize practices that get your mail delivered

Greg Svoboda Greg Svoboda

Bulk email has a reputation problem, but users often misplace the blame. 

Recipients associate bulk email with spam, inbox clutter, and irrelevant marketing campaigns. Senders associate it with poor deliverability, complicated orchestration, and the constant fear of landing in spam folders.

If you handle bulk email, these problems may sound familiar. The DIY Python approach — install smtplib, divvy up your mailing list in a CSV file, set up a loop function, hope for the best — all but guarantees delivery problems. The mail itself isn’t the problem, though.

Done properly, bulk email remains one of the most effective ways to communicate with customers at scale. The challenge is that mailbox providers aggressively punish bad sending behavior, even when it’s unintentional. 

Successful bulk email happens when you prioritize your reputation and choose professional-quality tools to maintain it. 

We’ll start with a high-level look at why we focus on reputation and then offer guidance on bulk email sending. 

Reputation: The start and end goal of successful bulk email

Bulk email helps build relationships, educate customers, promote products, and keep brand image fresh. It can be tempting to dive in and start chipping away at those goals, but it’s strategy that wins the race every time. 

Before sending anything to your bulk mailing list, let alone automating your bulk mail with Python code, turn your attention to your sender reputation:

The most successful bulk senders understand that reputation, deliverability, and engagement are tightly connected. And they only start sending when reputation management plans are in place. 

You could write a Python script to start dispatching marketing emails today — but it’s not a good choice without a solid foundation. 

Manage your sender reputation proactively  #

Mailbox providers evaluate the entire ecosystem around it to determine your sender reputation. Once your reputation begins to decline, it can be difficult to isolate a cause and find the changes that will fix it.

Beyond the standard advice, like implementing DMARC, practicing good DNS hygiene, adhering to anti-spam laws, and maintaining clean recipient lists, a few factors are especially important for bulk email.

Reputation extends beyond your sending domain #

While engagement metrics impact your sender reputation the most, other factors matter too. Many email marketers overlook the influence of other companies and domains associated with your content, including:

  • Marketing and advertising partners
  • Linked third-party websites
  • Image hosting domains
  • Shared branding assets
  • External tracking links

If your emails include links to low-quality or suspicious domains, or if domains with poor reputations frequently point back to you or use your branding, your reputation score can suffer.

Your email service provider matters, too #

Your email service provider (ESP) has a major impact on your bulk email deliverability. If you use the same ESP for bulk and transactional mail, find one with expertise in both. Ideally, separate transactional mail and bulk mail behind the scenes, as we do with Postmark’s Message Streams. 

A strong ESP maintains high-quality shared domains and is an active member of the email anti-abuse community. Look for an established ESP with a long deliverability track record. Some deliverability issues require direct communication between providers and mailbox operators. 

When reputation score alone isn’t enough, an ESP with strong industry relationships can often resolve issues faster and more effectively.

Watch bounce trends carefully #

Bounce management practices for bulk email differ from practices for transactional mail. With transactional mail, permanent bounces happen infrequently. Most bounces are transient; retry at least once. 

Bulk mail lists generate more permanent (hard) bounces, which require immediate attention — but not necessarily immediate action. 

Hard bounces quickly damage your reputation, rapidly leading to more deliverability problems. A slight increase in reputation-related bounces can reveal a developing problem before inbox placement drops significantly. Pay close attention to emerging patterns.

Be conservative with retries on bulk lists, though. If inbox providers see a problem, continuing to push volume can make the situation worse. Instead, pause, reassess, and fix the underlying issue before sending again.

Use webhooks to see what’s happening in real time #

Your ESP matters to your success in managing bounces and understanding engagement, too. A good ESP provides a variety of webhooks that let you customize alerts and data for quick notifications: 

Creating a webhook with the Postmark Python SDK takes just a few lines of code:

import asyncio
async def main():
    wh = await client.webhooks.create(
        url="https://example.com/webhook",
        message_stream="outbound",
        triggers={
            "Open": {"Enabled": True, "PostFirstOpenOnly": False},
            "Click": {"Enabled": True},
            "Bounce": {"Enabled": True, "IncludeContent": False},
            "SpamComplaint": {"Enabled": True, "IncludeContent": False},
        },
    )
    print(f"Created webhook ID: {wh.id}")
    print(f"URL:     {wh.url}")
    print(f"Opens:   {wh.triggers.open.enabled}")
    print(f"Bounces: {wh.triggers.bounce.enabled}")
asyncio.run(main())

If you connect that webhook to a Slack notification or Jira ticket, your team receives automatic notifications. The data comes back as JSON objects, like this:

{
  "RecordType": "Bounce",
  "MessageStream": "outbound",
  "ID": 4323372036854775807,
  "Type": "HardBounce",
  "TypeCode": 1,
  "Name": "Hard bounce",
  "Tag": "Test",
  "MessageID": "883953f4-6105-42a2-a16a-77a8eac79483",
  "Metadata" : {
    "a_key" : "a_value",
    "b_key": "b_value"
   },
  "ServerID": 23,
  "Description": "The server was unable to deliver your message (ex: unknown user, mailbox not found).",
  "Details": "Test bounce details",
  "Email": "john@example.com",
  "From": "sender@example.com",
  "BouncedAt": "2019-11-05T16:33:54.9070259Z",
  "DumpAvailable": true,
  "Inactive": true,
  "CanActivate": true,
  "Subject": "Test subject",
  "Content": "<Full dump of bounce>"
}

Populate data to a dashboard so you can see trends and details clearly. 

When you improve targeting and send better email, engagement improves. When engagement improves, so does deliverability.

Transactional and bulk mail: Keep them separate! #

Businesses generally send two categories of email: transactional and bulk or broadcast.

Transactional email is expected, urgent, and highly individualized. Bulk email, often used for marketing, is less time-sensitive, not triggered by user action, and is more likely to generate spam complaints.

When these two categories share infrastructure, mailbox providers may begin classifying transactional messages as marketing traffic, which can lead to issues like delayed password resets, missing receipts, or undelivered onboarding messages.

Separating traffic protects your most critical emails.

It also prevents traffic jams and backlogs for your bulk mail, reducing friction and keeping costs down.

DIY solution? Batch API? Separate ESP? Or a better way? #

To set up separate pipelines for your transactional email and bulk email, you have choices, but they’re not created equal, and won’t get you equal results.

Python built-ins won’t deliver #

The first temptation for many Python developers is to DIY it. Python has a wealth of built-in libraries that you could use to cobble together your own solution. 

Remember that your ESP’s reputation affects your deliverability, though — DIY solutions mean building your own reputation from scratch, plus handling rate limiting and bounce messages on your own. The process is time-consuming, buggy, and unreliable. 

Batch sending has its own role #

Some ESPs offer batch sending from their email APIs. While it’s possible to send one-to-many email using batch APIs, sending true bulk mail this way has drawbacks:

  • Need to fully define every message separately
  • Repeated uploads of duplicate content
  • Very large payload sizes
  • More data travels across the network
  • Senders often need manual throttling logic

Batch APIs work well when messages differ substantially between recipients, but they become inefficient at scale, especially when you send mostly one type of content, like a newsletter.

Avoid the headache of two ESPs #

Perhaps you already use an ESP for your transactional mail that you’re happy with. But if that ESP doesn’t fully support bulk messaging, you’re short-changing your own email marketing efforts. 

Among the top transactional email API providers, most don’t offer a robust bulk email service and can’t guarantee bulk mail will stay separate from transactional mail. 

Still, adding a second ESP — with a new API, a new dashboard, and new credentials — might not appeal to you. The options for third-party bulk email solutions tend to fall at the two extremes, with beginner-friendly options like MailChimp on one end, and bare-bones services like Amazon SES on the other.

Most of us need something in the middle, without a lot of heavy lifting. If you want to automate your bulk email without upending your existing transactional mail service, Postmark offers a unique value proposition.

The Easy Fix: Postmark’s Bulk API #

Postmark offers two distinct advantages for Python developers who need bulk email support. 

Instead of redefining the message repeatedly, with Postmark’s Bulk API, you:

  1. Define the message content once
  2. Pass recipient-specific variables separately
  3. Let Postmark compile the individual messages

This creates:

  • Smaller payloads
  • Faster uploads
  • Cleaner application code
  • Better scalability
  • Reduced network overhead

The Bulk API also automatically optimizes sending speed.

Mailbox providers can react negatively when they receive too much email too quickly. Intelligent throttling helps maximize inbox placement, saving devs the effort of building complex delivery-pacing systems.

Integrating the Python Bulk API is just like using Postmark for transactional mail #

Postmark offers something unique among email APIs — full support for bulk email with the same tools you use to automate transactional email.

Note: The Bulk API (/email/bulk) isn't enabled by default.  Postmark requires you to contact support to activate it on your account first, separate from normal transactional/batch sending. If you haven't done that, this code will fail with an error even once fixed.

Installing the Python SDK in your application lets you manage mass marketing emails and critical transactional mail with a single set of parameters, data sources, and credentials. 

Postmark provides consistent model definitions and methods, then handles the separation of concerns behind the scenes. This best-of-both-worlds scenario gives you top-quality professional email management and familiar, straightforward implementation: 

import asyncio
import postmark
from postmark.models.outbound import BulkEmail, BulkRecipient

async def main():
    async with postmark.ServerClient("YOUR_SERVER_TOKEN") as client:
        response = await client.outbound.send_bulk(
            BulkEmail(
                sender="you@example.com",
                subject="Hello {{FirstName}}, We've got news!",
                html_body="<p>Hi {{FirstName}}, We've loved having you as a customer since {{CustomerSince}}. As you know, we're always evolving! Read on for more news!</p>",
                text_body="Hi {{FirstName}}, We've loved having you as a customer since {{CustomerSince}}. As you know, we're always evolving! Read on for more news!",
                message_stream="broadcast",
                messages=[
                    BulkRecipient(
                        to="alice@example.com",
                        template_model={"FirstName": "Alice", "CustomerSince": "2021"},
                    ),
                    BulkRecipient(
                        to="bob@example.com",
                        template_model={"FirstName": "Bob", "CustomerSince": "2024"},
                    ),
                ],
            )
        )
        print(f"Bulk request ID: {response.id}  Status: {response.status}")

        status = await client.outbound.get_bulk_status(response.id)
        print(f"{status.percentage_completed:.0f}% of {status.total_messages} messages sent")

asyncio.run(main())

You can easily send a personalized email to thousands of recipients without worrying about rate limiting or throttling, and get clear, detailed information about message delivery.

If you’re sending newsletters, product announcements, platform notifications, or other large-scale campaigns, the Postmark Bulk API is an ideal fit. If you already use Postmark for transactional mail, you don’t even need to install any new tools. 

If you’re still not sure about the best option, take the Transactional vs Broadcast Message Streams quiz to find out what we recommend for your specific needs.

A good bulk email API controls key variables so you can grow #

A lot of bulk email advice ultimately comes down to three simple principles:

  1. Follow the rules: Adhere to DMARC requirements, GDPR, and CAN-SPAM, and unsubscribe policies.
  2. Avoid behavior that looks spammy: Maintain clean lists, respect subscriber preferences, and send only high-quality email.
  3. Use infrastructure specially designed for bulk mail deliverability: The easiest way to do that is to choose an ESP that matches your needs.

You probably already know about the first two. The third principle could be the most important variable, though, and it’s not one you can take on alone.

The Postmark Bulk API gives teams a scalable way to manage both transactional and bulk email from one platform while keeping the infrastructure properly separated. Using the Postmark Python SDK gives you quick access to all this functionality in a single package. 

By defining content once and letting Postmark automatically optimize delivery speed, teams can send large-scale campaigns more efficiently without sacrificing deliverability.

Postmark has focused on deliverability for years. Our reputation depends on our ability to keep protecting yours. For Python developers, there’s never been a better time to make us part of your email team. 

Greg Svoboda

Greg Svoboda