Create newsletters in Letterhead while sending through your own ESP

External sending lets you create and edit newsletters in Letterhead while sending them through Iterable or Mailchimp as your Email Service Provider (ESP). Letterhead acts as the editor; your ESP remains the sender — no need to migrate your audience, sending infrastructure, or existing workflows.

Iterable and Mailchimp are the most fully supported external providers, and the ones this article walks through step by step. Letterhead connects to a range of others as well — including SendGrid, Constant Contact, and Sailthru. The Sending settings page always shows the providers currently available to your account, along with a comparison of what each one supports, so check there rather than relying on a list in this article. You can connect more than one provider at a time and assign different connections to different newsletters.

1. Sender setup

Go to Settings → Sending at the company level and choose Add a New Connection. Connecting a provider is typically an admin task. Every connection walks through the same steps: configure the provider’s credentials, select the Letterhead newsletters that will use the connection, then select the audience list for each newsletter.

Iterable configuration:

• API Key (required) and API Region
• Sender Name and Reply Address
• From Address (optional) — must be on a domain verified in Iterable; leave it blank to use the reply address. This lets the sender address differ from your reply address — for example, a brand or no-reply address while replies go to a monitored inbox.
• Unsubscribe Tag — an additional field for deeper Iterable setups
• Per newsletter, you also set a Subscription Channel, a Message Type ID, and any Data Feed IDs

If a Message Type ID isn’t valid in Iterable

The Message Type ID you give a newsletter has to match a message type that exists in the Iterable project the connection sends from. If it doesn’t, Iterable refuses to sync the newsletter — and because that only happens later, at preview or send time, a wrong ID would sit there looking perfectly fine in the meantime.

Now the ID is checked against your Iterable project as you save. Enter one that isn’t there — a typo, or an ID copied from a different project — and the save is refused, with the offending field marked and a message naming the ID, so you can fix it while you’re still looking at the screen.

Two more things are worth knowing:

• Your saved IDs are re-checked every time you open these settings. A message type that was fine when you set it up can be deleted or renumbered in Iterable later, and nothing about your newsletter would look wrong until a send failed to sync. Instead, the ID is checked again each time the page loads, and one that no longer exists in the project is flagged right under the field you set it in — so you find out while you’re in the settings rather than after a send.
• If Letterhead can’t reach Iterable when you save, your settings still save. Checking an ID means asking Iterable which message types exist, and when that question can’t be answered we’d rather save your work than block it on a check we couldn’t finish. Everything on the page goes in exactly as you set it, and the re-check above picks up a bad ID the next time we can reach Iterable. An ID Iterable does tell us is invalid is still refused, as above — being unable to ask is not the same as being told no.

Mailchimp configuration — all four fields are required, and you can’t save the connection until each one is filled in:

• Prefix — your Mailchimp server prefix, visible in the URL when logged in to Mailchimp
• API Key
• List Id — the Mailchimp audience this connection works with. It’s the list Letterhead reads your contacts and engagement from, so choose the one your newsletter subscribers live in.
• Reply-to email address
• Per newsletter, you then choose which parts of that audience it sends to. The options are the saved segments and interest groups inside the list you entered above — so set those up in Mailchimp first if you want to send to anything narrower than the whole audience. You can also apply the same selection to every newsletter at once.

When you come back to edit a saved Mailchimp connection, the API key is masked and can’t be changed in place — the other fields stay editable.

This is the only place Mailchimp is set up. The same connection is what pulls your Mailchimp contacts into Letterhead, so there’s nothing separate to configure for that — see Company-Level CRM Audience Sync for what that sync does once the connection exists.

Once the connection is saved, Letterhead routes those newsletters to the selected ESP for delivery. Sending and deliverability are managed by the external provider.

Reassigning a channel from one company-level connection to another doesn’t disable anything — it just switches which connection sends the channel’s newsletters going forward. Existing templates and automations stay intact, and any newsletter you’ve already scheduled keeps its scheduled time.

2. Newsletter creation and previews

The full Letterhead editor still works: drag-and-drop blocks, custom templates, saved blocks, and previews and test sends — all inside Letterhead, even though the email sends through your ESP. If you have multiple providers connected, you can choose which provider a template sends through.

If you send through Iterable, you can also connect Iterable data feeds for per-recipient dynamic content — including personalized images — and connect data feeds at the channel level so every newsletter in the channel has access.

Put an Iterable snippet in a newsletter

The Iterable snippet block drops a snippet you maintain in Iterable straight into a Letterhead newsletter. The snippet’s own HTML never passes through Letterhead — Iterable fills it in at send time — so the content stays yours to change in Iterable without reopening the newsletter. (That’s also why a snippet block can’t carry a device or audience condition.)

Open the block’s settings and give it the name of the snippet you want.

Early access

Everything from here to the end of this section is rolling out gradually and may not be available on your account yet. Until it reaches you, the block simply takes a snippet name you type, and nothing checks that name against Iterable — so it’s worth confirming the spelling there first.

Instead of typing that name from memory, you pick it from a list of the snippets that actually exist in the Iterable project the newsletter sends from — searchable, so the exact spelling is one thing less to keep track of. And saving a name that isn’t in that list is refused on the spot with an error, rather than quietly going out as an empty block.

Three things worth knowing:

• If a snippet is renamed or deleted in Iterable, a newsletter that already used it keeps the name it was built with, and the settings tell you that name is no longer in the connected project. Nothing is rewritten behind your back — you decide what goes there instead, and you find out while you’re editing rather than after a send.
• If there’s no list to show you — usually because the newsletter’s channel has no connected Iterable project, or the project has no snippets yet — the block falls back to a name you type in, so you’re never left without a way to set one. There’s nothing to check it against in that case, so whatever you type is saved as it stands.
• If Letterhead can’t reach Iterable when you save, your newsletter still saves. Checking a name means asking Iterable which snippets exist, and when that question can’t be answered we’d rather save your work than block it on a check we couldn’t finish. The name goes in exactly as you set it and nothing is lost.

Between them, those last two are how a snippet that isn’t there can still get through. If a block comes back empty in a test send and you’re confident the name is right, re-open the block’s settings, check the snippet is listed, and save again — it will go out with the next send.

3. Audience management behavior

With an external sender selected:

• the channel’s Audience area in Letterhead is hidden;
• subscriber data stays managed in your ESP — make all audience updates directly in Iterable or Mailchimp;
• each newsletter sends to the audience list (and, for Iterable, message type) you assigned in the connection settings.

Letterhead still reads engagement signals from Mailchimp and Iterable to power its segment and cohort features at the company level.

4. Metrics and reporting

For newsletters sent through Iterable or Mailchimp, Letterhead captures per-send engagement metrics — opens, clicks, bounces, and unsubscribes — plus a per-link click breakdown, refreshed on an hourly sync. Delivered/accepted delivery metrics are only available for Letterhead-native sending, and for anything deeper — audience-level analytics, deliverability reporting — use your ESP’s native reporting.

5. Features not available with external sending

These rely on Letterhead’s native sending system and don’t function with external ESPs:

• Channel audience management in Letterhead
• A/B testing on subject lines
• Delivered/accepted delivery metrics

Is external sending right for me?

• Use Letterhead native sending for full access to audience tools, A/B testing, and delivery metrics inside Letterhead.
• Use external sending if you already rely on an established ESP and want to keep that setup while designing newsletters in Letterhead.

For everything the editor can do, see Working in Emails.