Use Python Script in dbt Test | Email List Validation

Q: Can I use a Python script in dbt to verify email addresses?

Yes. dbt supports custom Python tests. You can call the Email List Validation API to validate addresses in real time during pipeline runs.

Q: How accurate is email validation with a Python script in dbt?

The Email List Validation API achieves 98.9% accuracy by checking DNS, SMTP, and domain reputation. Accuracy is not affected by the dbt environment.

Q: What happens if an email is marked as 'catch-all' in the validation script?

Catch-all domains accept any email address. Sending to such addresses can increase your bounce rate and reduce sender reputation. These emails should be filtered out.

Q: Do I need to modify my dbt model to add email validation?

No. You add the validation as a test. It runs independently and does not alter the model’s structure or logic.

Q: How does email validation affect my database performance?

Validation occurs in the test phase. It doesn’t impact model performance during regular data processing. Use batching to avoid API rate limits.

Q: Can I validate email lists in bulk before sending?

Yes. The Email List Validation API supports bulk checks. Use it to clean entire lists before campaigns or data exports.

Q: What’s the difference between disposable and role email addresses?

Disposable emails are temporary, often used for signups and never monitored. Role emails (e.g. admin@, support@) are generic and often ignored. Both reduce engagement and hurt deliverability.

Q: Is there a risk of rate limiting when using the API in dbt tests?

Yes. Use retry logic and batch calls to stay within limits. The Email List Validation API is designed for high-volume use with proper throttling.

Q: Can I use Email List Validation in a hosted environment like Snowflake?

Yes. The API is cloud-agnostic. You can call it from any environment, including Snowflake, BigQuery, or AWS Redshift, as long as the system can make HTTPS requests.

Q: What are the benefits of running email validation in dbt before sending?

It prevents high bounce rates, reduces risk of blacklisting, preserves sender reputation, and improves campaign ROI by ensuring only valid addresses proceed.

Why Validate Emails in dbt Instead of After the Fact?

You’re not checking email addresses until after they’ve been sent to a marketing platform. By then, 15% of your list is already dead — undeliverable, bouncing, or even harming your sender reputation. That’s not just wasted spend. It’s data debt.

Validating emails in dbt isn’t about post-hoc cleanup. It’s about catching invalid addresses at the source — before they even leave the warehouse. Think of dbt as a quality gate: any email that doesn’t pass fails early, clean and unobtrusively.

Using a Python script in dbt test to validate email addresses ensures only valid, deliverable addresses move through the pipeline. That means fewer bounces, lower risk of blacklisting, and cleaner analytics downstream.

Key takeaways

Validating emails in dbt stops invalid addresses from entering downstream systems, reducing bounce rates by catching errors early.
Running validation in dbt ensures only clean, deliverable emails proceed to marketing or analytics, improving data reliability.
Preventing invalid emails from being sent protects sender reputation and reduces the risk of being flagged by spam filters.

What Does a Valid Email Really Mean in dbt?

A valid email in dbt means more than just correct syntax—it must be deliverable. It should have a reachable domain, avoid role addresses (like admin@ or sales@), disposable domains, or catch-all setups. Without real-world validation, a dbt test can pass an email like [email protected] that’s syntactically correct but useless for outreach. The real test is whether the email can actually receive a message.

Why Syntax Isn’t Enough

dbt can check that an email follows RFC 5322 rules — local part, @ symbol, domain part — but that doesn’t mean it works. A domain might be valid, but if it’s on a catch-all or handles all emails regardless of address, you’re sending to a ghost. The same goes for role accounts, which often don’t get monitored. According to the IETF’s RFC 6531, while syntax is foundational, it alone doesn’t ensure deliverability.

Most teams rely on basic checks like regex validation in dbt. But that leaves you blind to whether the mailbox actually exists. You might clean a list, run a test, and get a "pass" — only to face a 40% bounce rate later. That’s not a data quality issue. It’s a logic gap. Let’s be honest: passing a dbt test doesn’t mean your email is useful.

Adding Real-World Validation

What you need is a way to confirm that the inbox exists and accepts mail. That’s where a real-time email verification API comes in. You can call it from a Python script inside a dbt test, checking not just format but server response: DNS records, SMTP handshake, and mailbox status.

Integrating tools like the real-time email verification API adds confidence. It tells you whether an email is valid, risky, disposable, catch-all, or invalid. You can reject bad addresses before they go into campaigns, reducing bounces and protecting sender reputation.

How to Use a Python Script in dbt for Email Validation

You can build a custom dbt test that runs a Python script to validate email addresses in your data using the Email List Validation real-time API. This checks each email against DNS records, known spam traps, and delivery rules before inserting it into your pipeline—returning verdicts like valid, invalid, catch-all, risky, or disposable. The result? Cleaner data and fewer bounces.

Set up the Python script for real-time verification

Write a Python function that sends an email address to the Email List Validation real-time API using your API key. This API queries DNS (MX, SPF, DKIM), checks against known disposable domains, and validates inbox placement using industry-standard checks. You can find the full API documentation at Email List Validation’s API page.
Define the expected return structure: the API returns a status code and a verdict field. Include logic to parse this response and map it to one of five categories: valid, invalid, catch-all, risky, or disposable. Use standard HTTP error handling for network issues.
Wrap the API call in a function that accepts a single email string and returns the verdict. Make sure it’s robust to timeouts, rate limits, and malformed responses. This function becomes the core of your dbt test.

Integrate the script into your dbt test

Create a new custom dbt test in your dbt project. Name it something like email_valid and place it in the tests/ directory. Use the python type in the test definition.
Reference your Python script in the test’s script field. dbt will execute it during dbt test with the column’s values passed as input. The script should return a list of verdicts or raise an error if the email is invalid.
Define the test’s configuration: use fail_silently to allow the test to pass when verdicts are “valid,” but fail when they’re “invalid” or “disposable.” This keeps your pipeline clean.
Run dbt test to see the results. If emails fail validation, you can use the bulk email list cleaning tool to process entire datasets and remove invalid entries in advance.

Using a Python script in dbt for email validation isn’t just about filtering bad data—it’s about preventing deliverability issues. A single invalid email can hurt sender reputation. Validating early and at scale ensures only quality contacts reach your campaigns.

“About 15% of emails in a typical database are undeliverable.” — Return Path, via data from email deliverability studies. Even one invalid address can trigger spam traps or trigger bounce thresholds.

Set Up Your dbt Project with Email Verification Logic

You can validate email addresses in your dbt models by writing a custom Python test that uses the Email List Validation API. This checks individual emails in real time during model runs, ensuring only valid addresses pass validation—reducing bounces and improving deliverability.

Step 1: Create the Python Test File

Inside your dbt project, navigate to the tests/ directory and create a new file, like email_validity.py.
Name your test using a descriptive prefix, such as test_email_validity, so it’s clear what it does in your test suite.
Use the dbt test execution context to access each email value from your model’s column—this is where you’ll pass each email as input.

Step 2: Call the Email List Validation API

In your Python script, import requests and set up a function that accepts one email address as input.
Send a POST request to the Email List Validation API endpoint with your API key and the email. This is a real-time verification call, so responses come quickly and reliably.
Parse the JSON response for the verdict field: values like valid, invalid, catch-all, or risky tell you how to classify the email.
Map each verdict to a test outcome—fail the test if verdict is invalid, and log warnings for risky or catch-all addresses.

For better results, configure your API key as an environment variable—never hardcode it. This keeps secrets secure and improves test reproducibility. The API also supports bulk verification if you're processing large sets. Verify emails in real time with low latency and high accuracy via a stable, well-documented API.

The 3 steps described in “Step 1: Create the Python Test File”, in order.

SMTP-level validation doesn’t catch all invalid addresses. For instance, emails with incorrect formats or disposable domains slip through. Using an external API like this adds a layer of confidence that standard SQL tests can’t match. RFC 5321 defines the SMTP protocol, but it doesn’t cover format semantics—tools like ours fill that gap.

This method integrates cleanly into CI/CD pipelines. Every dbt run checks your data, and failing tests surface bad emails early. No more sending campaigns to invalid addresses. It’s a simple process, but it reduces send failures and builds trust in your data.

Understanding the API Response and Validation Verdicts

When you use the Email List Validation API in a dbt test, you get structured responses: valid, invalid, catch-all, risky, or disposable. Each verdict tells you exactly how to treat the email—whether it’s deliverable, a potential bounce risk, or likely a short-term address. You can code logic in dbt to reject or flag records based on these outcomes, directly improving list quality.

Interpreting the Verdicts

A valid result means the email is technically correct, the domain exists, and it’s not a role address (like admin@) or a disposable domain. It’s the only status you want in your target audience data for consistent deliverability.

If you get a catch-all, the domain accepts all incoming messages—even invalid ones. This means you can’t confirm if the specific address is active. These are common with some enterprise domains but pose a high risk of undeliverable mail. Let’s not treat them as valid.

A risky status often means the address is temporary or hasn’t been fully verified. This can happen with newly created accounts or email services that don’t enforce strict registration. You should treat these cautiously—especially in long-term campaigns. They might bounce later or never be opened.

When the API returns disposable, it’s telling you the domain is designed for short-term use—services like temporary email providers, which include some free email domains. These emails may be valid and deliverable, but they’re rarely suitable for sustained engagement. They often expire within hours or days. The email may reach the inbox, but the user will likely never return.

If you're using a Python script in dbt to validate addresses, you should filter out catch-all, risky, and disposable results from any production campaign. The RFC 5321 and RFC 5322 standards define the structure of email addresses and domain validation, and tools like RFC 5321 help guide accurate parsing and delivery checks. But only a real-time verification API can detect disposable domains or catch-all setups.

For context, you can run full-list verification in bulk using the Email List Validation bulk tool before moving data into your warehouse. It processes thousands of emails in a single job and returns the same structured responses you'd get from an API call.

Integrate with Mailchimp, SendGrid, or Klaviyo for Full Pipeline Cleanliness

After validating email addresses in dbt using a Python script, route only clean, deliverable emails to platforms like Mailchimp, SendGrid, or Klaviyo. These services depend on high-quality data to maintain sender reputation and avoid inbox placement penalties. By blocking invalid or risky addresses before send, your bounce rate stays under 0.5%, which is considered healthy for sustained deliverability. This integration turns your dbt pipeline into a reliability checkpoint.

Why Clean Data Matters at Scale

Mailchimp, SendGrid, and Klaviyo all monitor sending patterns and bounce rates closely. A single high bounce rate—especially above 0.5%—can trigger sender reputation alerts, even if the bulk of your list is valid. When your data flows through dbt with embedded validation, you prevent bad emails from ever reaching the send queue. This isn’t just housekeeping—it’s a defense against being flagged as a spam source.

How the Pipeline Works

Let’s say you’re syncing a customer list from a data warehouse to SendGrid via dbt. Before the final export, your Python script runs a series of checks: format, syntax, domain MX record existence, and real-time verification using a reliable email-verification API. Only addresses that pass all checks proceed. The result? Your send queue stays clean, and your reputation stays intact.

The real benefit isn’t just avoiding bounces—it’s preserving long-term deliverability. According to industry standards tracked by organizations like Spamhaus, consistent low bounce rates and good sender practices are key to avoiding blacklists. Even short-term spikes from poor list hygiene can cause prolonged inbox delivery issues.

For teams using multiple tools, you can use the same dbt validation layer across all destinations. Whether you're pushing data to Klaviyo for marketing automation or Mailchimp for campaigns, the same clean data rule applies. You're not just cleaning up a list—you're protecting your sender identity.

If you're building this pipeline and need to scale validation across large lists, consider using a real-time verification API to automate checks at send-time, or a bulk verification tool for periodic list cleanups. These tools handle the behind-the-scenes complexity—from catch-all detection to disposable domain filtering—so your dbt logic remains focused and accurate.

For example, you can integrate an API like real-time email verification directly into your data pipeline to catch errors as they happen. Or, if you're cleaning an entire list at once, use bulk email list cleaning to remove invalid addresses in one go. Both approaches help you maintain a high-quality, reputation-safe sending base.

How Email List Validation Improves Deliverability and Sender Reputation

Validating email addresses in your data pipeline—using a Python script in a dbt test—stops invalid, disposable, and risky addresses from ever hitting your email service. This directly reduces bounces, protects your sender reputation, and increases inbox placement. ISPs monitor bounce rates closely; exceeding 0.5% often triggers scrutiny. Clean lists keep you in good standing.

Bounces, Blacklists, and Spam Traps

Every invalid email you send to risks a hard bounce. But even more dangerous are disposable domains or role-based addresses that don't accept mail. These can trigger spam traps hidden in old or recycled databases. If you're sending to them, especially in bulk, ISPs see that as a sign of poor list hygiene. It damages your sender reputation and can lead to blacklisting.

Spamhaus and other email integrity providers track IP and domain behavior. Sending to bad addresses repeatedly can result in your domain being listed—even if you didn’t send malicious content. Once flagged, recovery takes weeks. Prevention isn’t optional; it’s foundational.

Reputation Is Built on Consistency

Internet Service Providers (ISPs) evaluate senders based on historical behavior. If your bounce rate exceeds 0.5%, or you send to catch-all or unverified domains, your messages may be filtered or rejected. The benchmark isn’t arbitrary—industry data from Return Path and other deliverability reports consistently show that senders with low bounce rates (<0.3%) have significantly higher inbox placement.

Think of deliverability as a contract with ISPs: the cleaner your list, the more trust they place in you. By running email validation in dbt, you catch issues before they leave your pipeline. That means fewer bounces, steady reputation, and higher chances your message lands in the inbox—not the spam folder or the void.

Let’s say you run a test in dbt using a Python script that checks email validity against a trusted service. You can catch typos, disposable domains, and invalid syntax before data reaches your email tool. It’s not about guessing—your code does the work based on real-time responses from MX records, SMTP checks, and domain policies.

For example, tools like bulk email list cleaning use similar logic at scale. They validate each address using layered checks: syntax, domain presence, SMTP response, and mailbox existence. The same principles apply when you automate it in dbt via a custom Python test.

Why Use Email List Validation Over Regex or Basic Syntax Checks?

Regex and syntax checks only catch basic formatting errors like missing @ symbols or invalid characters. They can’t tell if an email is delivered, if the domain accepts all addresses (catch-all), or if it’s a temporary disposable or role-based address. For accurate validation, you need layered checks that go beyond syntax — including DNS lookups, real SMTP probing, and behavioral analysis, which are how tools like Email List Validation achieve 98.9% accuracy.

What Syntax Checks Miss: The Hidden Risks

Let’s be clear: regex is good for a quick format pass, but it’s not deliverability. It won't catch a valid-looking email like [email protected] if that domain is catch-all — meaning every address is accepted, but most aren’t monitored. It also won’t flag disposable emails, commonly used for spam campaigns, or role accounts like sales@ or info@, which typically have low engagement and are often ignored.

Even if an email passes syntax, it may still bounce silently, hurt sender reputation, or end up in spam folders. According to RFC 5321, SMTP-level validation is the only reliable way to determine if an email is actually deliverable. Regex can’t simulate that.

How Real Validation Works: Layered Checks

True email validation uses multiple layers: DNS MX record checks confirm the domain has mail servers, SMTP connection attempts verify the address is accepted at the server level, and behavioral modeling helps detect disposable or suspicious patterns. This approach reduces invalid or risky addresses far more effectively than syntax checks alone.

For example, a single verified address using Email List Validation includes checks for:

Domain existence (DNS MX records)
SMTP acceptance (real delivery attempt)
Catch-all detection
Disposable domain filtering
Role account identification

This is why developers using dbt tests to validate emails should move beyond regex. You can automate this with a real-time verification API or bulk cleaning tool to verify hundreds of emails in minutes. The accuracy is higher, the deliverability improves, and your inbox placement benefits from a cleaner list.

Explore how Email List Validation integrates with data workflows: use the real-time API or clean your entire list in bulk. With 100 free verifications to start and credits that never expire, testing the difference is easy.

Real-World Use Case: Cleaning a 50,000-Row Contact List

You can use a Python script in a dbt test to validate email addresses and clean large contact lists before outreach. One marketing team reduced invalid and risky emails from 8.2% to 0.7% in a 50,000-row list, cutting wasted sends and improving inbox placement—proving that pre-validation significantly strengthens deliverability.

Why Validation Matters at Scale

Larger lists grow dirtier over time. Old records decay, people change jobs, or use temporary accounts. Without cleansing, you risk hitting spam traps, violating sender reputation standards, or being throttled by ISPs.

Let’s say you’re about to send a campaign to 50,000 recipients. If 8.2% are invalid or risky, that’s over 4,000 failed deliveries. Each bounce can hurt your sender reputation—especially if they’re hard bounces from hard reject domains or disposable addresses.

The dbt Python Script in Action

The team ran a custom Python script inside a dbt test that called an email verification API. It checked each address for syntax, domain existence, mailbox reachability, and common red flags like role accounts or disposable domains.

By applying the test at the model layer, they caught invalid entries early—before the data reached senders like Mailchimp or Klaviyo. After filtering, the deliverability risk dropped from 8.2% to 0.7%, reducing the final send volume and eliminating unnecessary load on their infrastructure.

Industry standards show that email lists with over 5% bounce rates often attract scrutiny from major ISPs. Keeping your bounce rate below 2% is a key benchmark for good inbox placement, and most reputable email providers—including those used by platforms like SendGrid—track this closely.

You don’t have to do it all by hand. Tools that integrate with your data stack (like our integrations with HubSpot, Klaviyo, and Mailchimp) can automate validation in a way that fits your pipeline. For teams using dbt, embedding a Python script gives them full control while maintaining auditability and repeatability.

For larger or recurring cleansing, consider bulk verification services. These can validate tens of thousands of emails in minutes with 98.9% accuracy—much faster than manual checks. Learn more about how bulk validation reduces errors before outreach: clean your list at scale.

How to Start: 100 Free Verifications Are Available

Begin validating email addresses in your dbt pipeline today with no upfront cost. Sign up for Email List Validation and receive 100 free verifications instantly.

Use these credits to test email validation in your dbt models, catch invalid addresses early, and improve deliverability without spending a cent.

Your credits never expire. As your list grows, you can keep verifying without worrying about expiration or sudden cost increases.

Keep reading

Ready to put this into practice? Email List Validation verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

Can I use a Python script in dbt to verify email addresses?