Integration
Run Braze from inside Claude.
Connect your Braze REST API key and Claude stops describing your program and starts working inside it — reading Canvas structure, campaigns, segments, and templates, and writing templates back. Braze is Orbit's deepest integration: seven of eight core operations run natively. Here's exactly what that covers, and the one place Braze's API draws a line.
You ask Claude to review a Canvas before it goes live — confirm the right template is bound to each step, check that the Liquid personalization has a fallback, make sure the "Everyone Else" path isn't silently absorbing users it shouldn't. Without a connection, Claude can tell you what to look for; it has never opened your Canvas. An MCP for Braze — a way to hand Claude Braze's real API instead of generic knowledge — closes that gap. It reads what's actually built: the templates, the segments, the Liquid in every message. The honest part is knowing where Braze's REST API lets Orbit read structure and where the dashboard is still the only ground truth — Canvas filter conditions, delay durations, and conversion events don't come back over the API at all, and Orbit says so instead of guessing. That's the whole page below.
What Orbit does with Braze today.
Seven of the eight rows below are native — the best ratio of any ESP Orbit connects to. The eighth, auth-check, still works; it's just not a dedicated endpoint, so the note explains the workaround rather than hiding it.
| The job | Status | What it means |
|---|---|---|
| Connect & auth check | Works, with a caveat | Braze has no dedicated ping endpoint, so Orbit probes with a cheap GET on the email template list (limit 1) to confirm the key and endpoint are live. |
| List email templates | Works | Full inventory of your Braze email templates, read natively. |
| Read a template's HTML | Works | Pull any single template's subject, body, and metadata — what's actually bound to a Canvas step, not a description of it. |
| Create & update templates | Works | Native template CRUD — Orbit writes a template into your Braze workspace directly. Pointing a Canvas step at the new template is still a dashboard action, done by hand. |
| Read campaigns & Canvases | Works | Campaigns and Canvas structure both read natively on the same surface. |
| Read segments | Works | Full segment inventory, read natively. |
| Pull performance metrics | Works | Native performance reads, no rate-cap workaround needed — a contrast with a couple of the other ESPs Orbit runs, where the reporting API is throttled. |
| Send a test | Works | Braze's messaging endpoint targets a designated test list directly, so Orbit fires a real send — not only a local QA pass on the HTML. |
How to connect Braze.
Two fields. Braze is a REST API — no OAuth flow, no separate app to install.
braze_api_key
Your Braze REST API key, with read/write scope for the operations above. Generate it in Braze under Settings → APIs and Identifiers.
braze_endpoint
Your Braze instance's REST endpoint — a cluster URL specific to your workspace, for example rest.iad-01.braze.com. Braze shows the right one for your account in its own API documentation.
That's the whole setup. If either field is missing or wrong, Orbit tells you exactly which one to fix — it never fails silently or crashes mid-task.
What makes this the deep integration.
It isn't only the eight-row table above. A handful of tools exist because they target objects with no equivalent on any other ESP: reading and building Canvas structure, auditing Content Blocks, and uploading to Braze's media library. There's no honest Klaviyo or Mailchimp mapping for a Canvas audience-path group, so Orbit doesn't invent one.
Two mechanics are worth naming because they're the ones that actually bite. First, Braze's API rarely returns a message step's bound template name — the title field usually comes back null— so a Canvas QA pass fingerprints each step by its subject, preheader, and a distinctive content block instead of trusting a label. Second, audience-path filter conditions, group ranking, delay durations, and conversion events don't come back over the API at all; the dashboard's Canvas Flow editor is the only ground truth for those, and a QA pass says so rather than guessing from what the API can see.
Orbit also validates Liquid — the templating language Braze email runs on — checking that every variable reference has a fallback and that content-block references resolve, before a template goes anywhere near a send.
Beyond the Braze API.
The API connection is half of it. The other half is the portable layer that works the same whichever ESP you're on: 80 skills that encode real lifecycle methodology, 126 tools, and a production email pipeline — MJML that compiles to clean HTML, a render preview, and a QA gate that checks dark mode, clip length, and accessibility before anything goes near a send.
For Braze specifically, that pipeline ends by pushing the compiled template into your workspace and, once it's bound to a Canvas step, running the same pre-launch checklist a careful lifecycle team runs by hand: entry rules, segment definitions, template bindings, Liquid fallbacks, delays, conversion events, exit criteria. Nothing launches during a QA pass — it stays on Save. The calculators — sample size, holdout maths, LTV — are ESP-neutral too; none of that depends on which platform you connected.
Try it with your Braze account.
Orbit is free — every skill and tool included, no seats and no subscription. Paste your Braze REST API key and it goes from advisor to operations layer the same afternoon.
Run a different ESP?
The same honest treatment, per platform:
Frequently asked.
Is Orbit's Braze integration really the deepest one?
Yes, by the numbers. Braze is the only ESP Orbit runs where seven of the eight core operations are native — auth-check, template read and write, campaign and Canvas read, segment read, performance metrics, and test send. The eighth, auth-check, is native in effect but Braze has no dedicated ping endpoint, so Orbit probes with a cheap template-list read instead. No other ESP Orbit connects to clears that bar.
Can Orbit send a real test email through Braze?
Yes. Braze's messaging endpoint lets Orbit target a designated test list directly, so it fires an actual send through Braze rather than only running a local QA pass on the HTML. That's a genuine advantage over ESPs with no test-send endpoint at all, like Klaviyo — there, Orbit's local QA gate is the only proof available before a send.
Does Orbit QA a Braze Canvas before it launches?
Yes, and it's upfront about where the API stops. Braze's REST API doesn't return audience-path filter conditions, delay durations, or conversion events — those only exist in the dashboard's Canvas Flow editor, so Orbit treats the dashboard as ground truth for them rather than guessing. What the API does confirm — which templates are bound, whether Liquid variables have fallbacks, whether a segment exists — Orbit checks directly, and a Canvas QA pass never launches anything; it stays on Save.
What credentials does Orbit need for Braze?
A Braze REST API key with read/write scope, plus your instance's REST endpoint (the cluster URL, something like rest.iad-01.braze.com— it's specific to which Braze instance your workspace runs on). Generate the key in Braze under Settings → APIs and Identifiers. Both fields go into Orbit's config once; after that, Claude reaches for Braze whenever the job needs it.
Does Orbit handle Braze's Liquid personalization?
Yes — Liquid is Braze's templating language, and Orbit validates it before a template goes near a send: every variable reference needs a fallback, and content-block references have to resolve. That check is specific to Liquid; it's not the right gate for an ESP like Iterable, whose templates are Handlebars, not Liquid.