Integration
MCP for Marketo: Claude, reading your instance.
Connect Adobe Marketo Engage with your own API credentials and Claude stops reciting Marketo best practice in the abstract — it reads the programs, smart campaigns, tokens, and lead data you actually have, and audits them. All inside the daily API quota, read-first by design.
A Marketo instance that's been running for a few years is a museum of good intentions. Programs named three different ways by three different people who've since left. Channels applied inconsistently, so the reporting rolls up wrong. Tokens defined once and then ignored, with the same values hardcoded across a dozen emails. You know it needs a clean-up, and you know roughly where the bodies are — but pulling the whole picture together by clicking through the tree, program by program, is a week you don't have. Ask Claude to help and it gives you a sensible checklist for auditing Marketo. A generic one. It has never seen your instance. An MCP for Marketo — a way to hand Claude the REST API instead of general knowledge — is what closes that gap. Claude reads your actual programs and tells you which ones are the problem.
What "MCP" actually means here.
MCP stands for Model Context Protocol, an open standard from Anthropic that lets Claude reach outside the chat window. Think of it as a plugin system, except the plugins don't add small features — they give Claude entirely new capabilities: tools that read your data and reason over it. Orbit is one such MCP, built for lifecycle marketing. Install it, connect your Marketo credentials, and Claude gains the ability to read your instance through the REST API. You don't learn a new interface. You talk to Claude the way you already do, and it knows when to reach for what Orbit added. The full walk-through of what an MCP is and how it changes the work lives on the MCP for marketing page →.
What Orbit does with Marketo today.
No hand-waving. Marketo's REST API splits into an Asset API for structure and a Bulk Extract API for volume, and the two behave differently — so the honest answer varies by row. Where there's a limit, it's named, and it's separated into two kinds: a real shape of Marketo's API, and a deliberate choice on our side to stay read-first with an enterprise instance.
Check the connection
Works todayOrbit exchanges your client id and secret at Marketo's identity endpoint for a bearer token, confirming the LaunchPoint service is live and scoped before it touches anything else.
Read your programs
Works todayEvery program with its channel, tags, folder, and the assets inside it — the structural map an audit is made of. Marketo's Asset API returns this cleanly.
Read smart campaigns
Works todaySmart campaign metadata, including the trigger and flow steps, read through the Asset API. Claude can see how the automation is wired without you exporting a screenshot of it.
Read my.tokens
Works todayProgram-level and folder-level tokens, the variables that keep personalisation and reuse consistent. Reading them is how Orbit spots a program hardcoding a value that should be a token.
Read smart lists and segmentation
Works todaySaved smart lists and segmentation definitions — the logic behind who receives what, so Claude reasons about the real audience cuts rather than inventing generic ones.
Read lead data
Partial — API shapeSingle-lead and smart-list-membership reads are native and cheap. A full database pull runs through the Bulk Extract API against a 500MB daily budget, so Orbit paces large exports and tells you the cost before it starts — it never launches an uncapped crawl.
Read email performance
Partial — API shapeMarketo has no one-call email-stats endpoint. Delivered, opened, and clicked live as activity records, so performance comes from the Bulk Activity Extract — asynchronous and quota-metered. Orbit requests and parses it as a considered pull, not a live feed.
Trigger campaigns and sends
Read-first by designThe REST API can request a smart campaign, but Orbit stays read-first with Marketo by design. It audits and hands you the fix to approve in Marketo, rather than firing anything into a live B2B database on its own.
The short version: Orbit reads your whole Marketo structure — programs, smart campaigns, tokens, smart lists — cheaply and natively, and reaches lead and activity data through Bulk Extract at a measured pace. What it won't do is trigger a send. That one's a choice, not a wall: reading an instance to audit it is safe, and firing a campaign into a live B2B database is the kind of thing that should stay in your hands.
How to connect it.
Three values, all from your own Marketo admin — no Adobe app to install and no OAuth redirect. In Marketo, go to Admin → LaunchPoint and create a new custom service, which gives you a client id and secret. Then grab your REST endpoint from Admin → Web Services. Paste all three into Orbit's config.
- Client ID & Client Secret— the custom-service credentials from LaunchPoint. Orbit exchanges them at Marketo's identity endpoint for a bearer token that lasts about an hour, and refreshes it in the background so you never think about it.
- REST endpoint — your instance URL, the one shaped like
https://123-ABC-456.mktorest.com. It carries your Munchkin id, so it tells Orbit exactly which instance to call.
Orbit stores the credentials as secrets and they never leave your machine in plain text. Scope the custom service to read-only in Marketo and Orbit works within exactly the access you granted — nothing more.
The quota is real, so we treat it as a budget.
Marketo's API limits are lower than most SaaS platforms, and they're shared across every integration touching your instance — your CRM sync included. The defaults: 50,000 API calls a day, 100 calls per 20 seconds, and 10 concurrent calls. Bulk Extract has a separate 500MB daily ceiling for lead and activity exports.
Orbit is built around those numbers rather than pretending they don't exist. It reads asset metadata cheaply and caches it, so re-reading a program you already looked at costs nothing. It never launches an uncapped crawl of your database. And before any Bulk Extract job, it tells you what the pull will cost against your daily budget, so a heavy export is a decision you make, not a surprise you discover when your CRM sync starts failing.
What the read is actually for.
Reading Marketo is the connection. The point is what Claude does with the read. Three audits pay for themselves the first time you run them on a mature instance:
- Program naming hygiene— Claude reads every program name at once and finds the drift: the three conventions fighting each other, the test programs never archived, the launch that never got its date prefix. A naming standard is only worth having if you can see where it's broken.
- Channel and tag consistency — every program carries a channel and its tags, and your reporting rolls up through them. Claude checks the channel against what the program actually does and flags the mismatches that skew a quarterly report before anyone notices.
- Database health — field completeness, duplicate patterns, smart lists whose logic no longer matches their name. Read against your real lead data, not a checklist of things that might be wrong in some other instance.
None of this is Claude guessing. Every finding points at a named program, token, or list you can open in Marketo and check.
What's deepest on Braze — and why we say so.
Orbit works with every major ESP, but its deepest single-platform integration is Braze, where the write path runs end to end. A handful of Orbit's tools are built around concepts that only exist in Braze — Canvas flows, Content Blocks, its media library — and those stay Braze-named on purpose. Faking a Marketo equivalent would just be a worse version of something Marketo models its own way.
For Marketo, the honest fit is the read: connecting Claude to an enterprise instance so it can reason over your real programs and audit them against a practitioner's standard. That's the work most Marketo teams actually need help with, and it's exactly what the REST API is good at handing over.
The half that isn't about the API at all.
Reading Marketo is the connection. The reason to bother is everything Claude does once it's connected. Orbit ships 79 lifecycle skills — structured protocols for the actual jobs: auditing a program, laddering a nurture, scoring a subject line, sizing a test. Those are platform-agnostic; they work the same whether the instance underneath is Marketo or anything else.
Underneath sit 130 tools — the calculators a real analysis needs: sample size, holdout maths, LTV and payback. Marketo runs the enterprise sends. Orbit gives you the practitioner sitting next to the instance, reading it the way an experienced operator would on their first day auditing your account.
Is this for you?
This is for the B2B marketing-ops person who owns a Marketo instance and wants a second set of eyes that has actually read it — the person who knows the naming has drifted, suspects the channels are wrong, and can't face clicking through four hundred programs to prove it. If that's your quarter, Orbit does the reading and points at the problems by name. It's a weaker fit if you want a tool that runs your sends for you; Orbit stays read-first with Marketo on purpose. What it gives you instead is a Claude that works like a marketing-ops auditor rather than a search engine — and a straight answer about what the REST API can and can't do, which is rarer than it should be.
Try it.
Orbit is free — every skill and tool included, no seats and no subscription. Create a read-only custom service, paste the three values, and Claude goes from advisor to a set of eyes on your instance the same afternoon.
Frequently asked.
What is an MCP for Marketo?
An MCP — Model Context Protocol, an open standard from Anthropic — gives Claude real tools instead of general knowledge. Connected to Adobe Marketo Engage through Orbit, Claude reads your instance over the REST API: programs and their channels, smart campaigns, smart lists, my.tokens, and lead data. So instead of describing Marketo best practice in the abstract, Claude reasons about the naming, the tokens, and the database health you actually have.
How does Orbit connect to the Marketo REST API?
Through your own credentials. In Marketo you create a custom service under Admin → LaunchPoint, which gives you a Client ID and Client Secret. You also copy your REST endpoint — the instance URL that looks like https://123-ABC-456.mktorest.com. Paste those three values into Orbit's config. Orbit exchanges the id and secret at Marketo's identity endpoint for a bearer token that lasts about an hour, and refreshes it as needed. No Adobe app to install, no OAuth redirect dance.
Will Orbit blow through my Marketo API quota?
No — the quota is treated as a hard budget, not a suggestion. Marketo's defaults are real and low by SaaS standards: 50,000 API calls a day, 100 calls per 20 seconds, and 10 concurrent calls. Orbit reads asset metadata (programs, campaigns, tokens) cheaply and caches it, and it never launches an uncapped crawl of your lead database. The one place volume adds up is activity and lead export, which runs through the Bulk Extract API and its own 500MB daily ceiling — Orbit paces that and tells you what a pull will cost before it runs.
Can Orbit read Marketo email performance?
Partly, and the limit is Marketo's shape, not Orbit's. Marketo has no simple email-stats REST endpoint the way it has one for reading a program. Delivered, opened, clicked, and unsubscribed live as activity records, so real performance numbers come from the Bulk Activity Extract — an asynchronous, quota-metered job, not an instant read. Orbit can request and parse that extract, but it's a considered pull against the 500MB daily budget, not a live dashboard that refreshes on every glance.
Can Orbit trigger smart campaigns or send email in Marketo?
It reads them; it doesn't fire them. The REST API can request a smart campaign and schedule assets, but Orbit stays read-first with Marketo on purpose — auditing an enterprise B2B instance is where it earns its place, and triggering a campaign against a live lead database on its own is not a thing you want an assistant doing for you. Orbit reads your smart campaigns, flags the naming, token, and channel problems, and hands you the fix to approve in Marketo. Its deepest write integration is Braze; for Marketo, the value is the honest read.