How to build Stripo emails with Claude — and push them straight to Braze

Start with what Stripo is, because the integration only makes sense once that's clear. Stripo is a drag-and-drop email builder — you assemble emails from saved blocks the platform calls modules (a header, a hero banner, a content section, a footer) and reuse them across campaigns so you're not rebuilding the same header every week. If you send any volume of email, you almost certainly have a Stripo module library already. That library is the asset Orbit cares about.

Orbit is a lifecycle-marketing MCP — a Claude Desktop extension that gives Claude a set of specialist tools. One of those tools talks to Stripo's REST API — the programmatic interface Stripo exposes so outside software can read and write to your account. Connect it once and Claude can do four things without you touching the editor: pull your Stripo modules down, compose a new email by stitching the right modules in the right order, render the result so you can check it, and export the finished email to a Braze template.

The practical difference is that nothing goes stale. When you drive Stripo by hand and paste HTML into an AI tool, the moment a module changes in Stripo your pasted copy is wrong. With the API connection, Claude reads your live Stripo library on every sync — what it composes from is what's actually in your account.

The setup is one tool: orbit_setup_stripo. Run it in Claude with Orbit installed and it checks your credentials, tells you exactly what's missing, and points you at the right page in Stripo's settings to fix it. The output is a live checklist that re-runs cleanly, so you can keep going until every line is green.

There's one detail worth knowing before you start, because every team hits it. Stripo has two different sets of credentials, and they are not interchangeable.

Once you're connected, run orbit_sync_stripo_modules. This pulls every saved module out of your Stripo library — its HTML, and Stripo's own classification tag for what kind of block it is — into Orbit's local mirror. A header stays a header, banners become heroes, content blocks stay content, footers stay footers. No manual tagging.

If the sync returns zero modules, that's the signal that your Stripo library is empty, not that something broke. The fix is to save two or three blocks in Stripo's editor first — right-click any block, choose Save as module — then re-run the sync. Orbit only ever sees modules you've saved; Stripo's public template gallery isn't exposed through the API, so everything Claude composes from is your own approved work.

The next move is orbit_document_stripo_design_system, which reads the synced library and writes a single markdown brief: an inventory of every module, the brand tokens it detects across them (button colour, text colour, font, padding), the composition rules it infers, and the gaps it spots — two modules sharing a name, a footer missing its unsubscribe variable, modules that fell into Stripo's catch-all bucket because they weren't tagged. Reading that brief is a genuinely useful audit of your own Stripo setup. It's also the document Claude consults before composing, which is why the emails come back on-brand by construction rather than by review.

Now the part that does the work. You give Claude a brief in plain language — "welcome email for new signups, lead with the value prop, end with our standard footer" — and it reads the design-system brief and your synced module list, picks an ordered sequence of modules, and calls orbit_compose_stripo_email. No structured input format, no schema. A sentence is enough.

The compose tool validates the structure before it builds: exactly one header, exactly one footer, header at the top, footer at the bottom. If Claude assembles something with two headers, the tool rejects it with an error code Claude can self-correct from inside the same conversation. Then it stitches the modules into a full HTML email — proper doctype, deduped CSS (one shared stylesheet rather than a copy per module), every block wrapped in its own table row, and the hidden Stripo block IDs preserved so the email round-trips back into Stripo's editor cleanly later.

The assembled HTML renders in chat as a visual artifact — you see the actual email, the way it'll look in the inbox, not a description of it. If something's off, you say so ("swap the social footer for the standard one", "tighten the headline"), Claude re-composes, and the preview re-renders. The whole loop is conversational, and nothing crosses into Stripo or Braze until you say so.

Once the email looks right, you export it to Braze. Orbit takes the composed Stripo HTML and writes it to a Braze email template — Braze being the customer engagement platform most lifecycle-heavy teams send from. The export matches on template name: if a template with that name already exists in your Braze workspace, Orbit updates that one; if it doesn't, Orbit creates it. No silent duplicates, no "which of these four identically-named templates is the live one" archaeology six months later.

That naming discipline is the difference between a Braze workspace you can navigate and one you can't. The dedupe-by-name behaviour leans on the same convention thinking covered in the Braze naming conventions guide — give the template a clear, stable name once and every future export from Stripo lands on top of it cleanly.

The handoff stays clean on both ends. Stripo holds the editable email — your designer can open it in Stripo's editor and tweak whatever needs tweaking. Braze holds the deployable template, ready to drop into a campaign or canvas. Orbit composes and moves the asset between them; it doesn't replace either tool. Stripo stays the source of truth for the build, Braze stays the place you send from.

Five steps, in order, the first time you set it up:

1. Connect with orbit_setup_stripo — it tells you which of the two Stripo credentials you're missing and where to get it.

2. Sync with orbit_sync_stripo_modules, then document the design system. Zero modules means save a few in Stripo's editor first.

3. Compose by asking Claude in plain language. The artifact renders inline; iterate in chat until it's right.

4. Verify bindings with a probe email if the modules use Smart Element variables — registration in the editor isn't proof of substitution at send.

5. Export to Braze, deduped by name, ready to deploy.

If you don't have a paid Stripo plan with API access, none of the above is available to you — but the older paste-driven flow (copy the HTML, let Claude rework it, paste it back) still works and is perfectly serviceable for one-offs. The API workflow earns its place when Stripo is your daily email production tool and you're tired of the clipboard tennis.

For the protocol-level view — how Orbit recovers from a missing REST token, a plan-tier block, or an empty library — see the Stripo Integration skill. For the deeper architecture and the full binding-verification recipe, read the native Stripo integration guide. The one thing to do today: connect your Stripo account and run a sync. Once Claude can see your modules, every new email is composition instead of construction.