# Two email providers on one domain without breaking auth

> Running a workspace mailbox provider and a transactional sender on the same domain? Combine SPF, give each its own DKIM selector, and align DMARC.

- Published: 2026-09-24
- Author: Koltrix Team
- Category: Guides
- Source: https://koltrix.com/blog/two-providers-one-domain

Most companies end up with at least two systems sending mail as the same domain: a mailbox provider for people and a transactional service for the application. Getting both to pass SPF, DKIM and DMARC is not hard, but it does require knowing which record each provider actually needs.

## The setup we are solving for

Assume `example.com` uses:

- **Provider A** for staff mailboxes (people sending from `alex@example.com`).
- **Provider B** for application mail (receipts, password resets, alerts from `notifications@example.com`).

Both send with a From address at `example.com`. Both need to pass DMARC, which means each message needs SPF or DKIM to pass *and* align with `example.com`.

## Step 1: understand which identity each check uses

The confusion usually comes from mixing up three different domains on a message:

| Identity | Where it appears | Checked by |
|---|---|---|
| Envelope sender (`MAIL FROM`, Return-Path) | SMTP transaction; copied into Return-Path header | SPF |
| DKIM signing domain (`d=`) | DKIM-Signature header | DKIM |
| Header From | The From line users see | DMARC alignment |

DMARC passes when SPF passes for an envelope domain that aligns with the From domain, or when DKIM passes for a `d=` domain that aligns with the From domain. With relaxed alignment, the default, a subdomain aligns with its parent: `bounce.example.com` aligns with `example.com`.

This is why two providers can coexist cleanly. They do not have to share everything; each needs one aligned pass.

## Step 2: SPF, one record, both providers

There can be only one SPF record per name. If both providers use `example.com` as the envelope sender, combine their mechanisms:

```text
example.com.  TXT  "v=spf1 include:_spf.provider-a.example include:spf.provider-b.example ~all"
```

Many transactional providers, however, use their own bounce domain by default, or let you configure a custom one such as `bounce.example.com`. That is better:

```text
example.com.         TXT  "v=spf1 include:_spf.provider-a.example ~all"
bounce.example.com.  TXT  "v=spf1 include:spf.provider-b.example ~all"
```

Now Provider B's SPF check happens against `bounce.example.com`, which has its own ten-lookup budget, and relaxed alignment still matches `example.com`. Provider B usually also needs an MX record on the bounce subdomain so that bounces flow back to it; follow their instructions for that name.

Before publishing, count lookups. Mailbox providers often use nested includes that consume several of your ten.

## Step 3: DKIM, a selector per provider

DKIM is where coexistence is easiest. Each provider signs with its own private key and publishes (or asks you to publish) its public key at a different selector:

```text
pa1._domainkey.example.com.   TXT    "v=DKIM1; k=rsa; p=MIIBIjANBgkq..."
pb1._domainkey.example.com.   CNAME  pb1.dkim.provider-b.example.
```

The selector name is the `s=` value in the DKIM-Signature header. A receiver looks up `<selector>._domainkey.<d= domain>` to find the key. Because selectors are independent names, any number of providers can sign for the same domain without conflict.

Two things to check:

1. **The `d=` domain must align.** Some providers sign with their own domain by default (`d=provider-b.example`). That DKIM signature can pass, but it does not align with `example.com` and does not help DMARC. Enable custom-domain signing so the signature uses `d=example.com` or a subdomain of it.
2. **Use 2048-bit keys where offered.** Longer keys may need to be split into multiple strings in a TXT record. Providers that use a CNAME at the selector host the key themselves, which also lets them rotate it without asking you.

## Step 4: DMARC, one policy covering both

DMARC is a single record at `_dmarc.example.com`:

```text
_dmarc.example.com.  TXT  "v=DMARC1; p=none; rua=mailto:dmarc-reports@example.com"
```

Start at `p=none` and read the aggregate reports. You want to see both providers' sending IPs appear, each with DKIM passing and aligned (and ideally SPF too). Once every legitimate source passes, move to `p=quarantine` and then `p=reject`.

## Step 5: verify each stream separately

Send a real message from each system to a mailbox you control and read the Authentication-Results header:

```text
Authentication-Results: mx.receiver.example;
  spf=pass smtp.mailfrom=bounce.example.com;
  dkim=pass header.d=example.com header.s=pb1;
  dmarc=pass header.from=example.com
```

For a staff message you would expect `smtp.mailfrom=example.com` and `header.s=pa1`. If either stream shows `dmarc=fail`, check which identity failed and whether it aligned.

## Common pitfalls

- **Two SPF records.** Adding Provider B's record as a second `v=spf1` TXT instead of merging produces a permerror for both.
- **Unaligned DKIM.** Provider B signs with its own domain; everything looks green until you enforce DMARC.
- **Forgotten third and fourth senders.** Support desks, CRMs, billing systems and form tools often send as your domain too. DMARC reports reveal them.
- **Reusing selectors.** If two systems publish keys at the same selector name, one overwrites the other.
- **MX confusion.** Adding a transactional provider never requires changing the root domain's MX records, which control inbound mail for your staff. Only a custom bounce subdomain needs its own MX.

## Where each provider's bounces go

Bounce handling follows the envelope sender. When Provider B uses `bounce.example.com` with an MX pointing to its infrastructure, bounces return to Provider B, which can suppress bad addresses and report them to you through its dashboard or webhooks. Staff mail continues to bounce back to Provider A through your root domain's MX records. Keeping that separation clean matters: if the application's bounces landed in a staff mailbox, nobody would process them, and your application would keep sending to dead addresses, which hurts reputation over time.

## Reputation is shared, so coordinate

Both providers send as `example.com`, which means receivers build a single picture of the domain from both streams. A spike in complaints from application mail can affect how staff mail is filtered, and the reverse. Separate envelope subdomains help a little, but the visible From domain is what many filters weigh most heavily. If one stream is riskier than the other, such as marketing compared with password resets, consider giving it its own From subdomain as well, so problems in one stream stay contained.

## A short checklist

- One SPF record per name, all senders using that name included, under ten lookups.
- A custom bounce subdomain for the transactional provider where supported.
- A distinct DKIM selector per provider, signing with `d=` aligned to your domain.
- A DMARC record with aggregate reporting, starting at `p=none`.
- Authentication-Results checked on a real message from each system.
- A move to enforcement only after reports show every legitimate source passing.

## Bottom line

Two providers on one domain work fine when you give each its own lane: a combined or separated SPF setup, an independent DKIM selector with aligned signing, and one DMARC policy watching both. Verify each mail stream on its own, and let aggregate reports tell you when it is safe to enforce.
