Integration
MCP for Amplitude: Claude, reading your product analytics.
You are planning a win-back, and the first honest question is: which cohort is actually slipping, and by how much? The answer is in Amplitude — the retention chart, the activation funnel, the cohort that stopped coming back after week two. So you open Amplitude, screenshot the curve, paste it into the chat, and ask Claude to reason about it. Claude gives you good thinking about a picture it can't query. It has never seen the cohort definition, the funnel drop-off, or last month's D30 number. An MCP for Amplitude — a way to hand Claude your own read key instead of a screenshot — is what closes that gap. Now Claude queries the real engagement data your lifecycle decision turns on, straight from the account.
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 these plugins hand Claude entirely new capabilities: tools that read your data and reason over it. Orbit is one such MCP, built for lifecycle work. Install it, connect an Amplitude key and secret, and Claude gains the ability to read your product analytics — cohorts, events, funnels, retention, user activity. Orbit is not an official Amplitude product; it's an independent MCP that calls Amplitude's public Dashboard REST API with the credentials you provide, and nothing leaves your machine except those read calls. The full walk-through of what an MCP is and how it changes the work lives on the MCP for marketing page →.
What Orbit reads from Amplitude today.
No hand-waving. Amplitude's Dashboard REST API are the analytics-read surface, and most of what a lifecycle decision needs is native to them. Where there's a limit, it's named — and we separate three different things: what Amplitude's API reads natively, where an API limit means Orbit works around a boundary, and what Orbit won't do at all because writing to Amplitude isn't what a read integration is for.
Confirm the connection and name the project
Reads todayAmplitude keys are scoped to a single project. Orbit checks that your API key and secret resolve and tells you which project you are reading, so there is no ambiguity about whose data the analysis is running against.
Read a behavioural cohort
Reads todayOrbit lists your saved cohorts and reads each definition through the Cohorts API — the behavioural rule that puts a user in the group. This is the raw material for asking which segment is slipping and why, before any message is designed.
Read event volume and segmentation
Reads todayThe Event Segmentation endpoint returns an event broken down by any property over a date range. Claude can size how often something happens and split it by plan, platform, or any dimension you track — the counts a real engagement read is made of.
Read a funnel
Reads todayThe Funnel Analysis endpoint returns conversion and drop-off across an ordered sequence of events. Point Claude at your activation or onboarding funnel and it reads where users fall out, step by step, instead of asking you to describe it.
Read a retention curve
Reads todayThe Retention Analysis endpoint returns return-rate curves. Claude reads the actual D1, D7, D30 shape of your retention — the number that decides whether a win-back is worth building at all. One real limit, named: Amplitude defines the start and return events as fixed states (new or active users returning), so a curve keyed to a custom event is not on offer; Orbit models that as two event reads instead.
Look up a user's activity
Not built — by designAmplitude publishes User Search and User Activity endpoints, and Orbit calls neither. A single person's event timeline is the highest-sensitivity read on the platform and the lowest-value one for a lifecycle decision, which is made on cohorts and curves. Orbit reads aggregates only.
Export raw events
Not built — by designAmplitude's Export API returns raw event data as zipped hourly JSON. Orbit does not call it. A raw event firehose is not what a lifecycle decision runs on, and streaming one through an AI session is a privacy cost with no matching benefit. Export it yourself and point Orbit's analysis at the file.
Download full cohort membership
Not built — by designAmplitude's Cohorts API can hand back the member list asynchronously. Orbit reads a cohort's definition and its membership COUNT, and stops there — the per-user rows are deliberately not built, for the same reason as the two rows above. The count is what tells you a cohort is slipping; the names do not.
Write events back into Amplitude
Not built — by designAmplitude has an HTTP ingestion API, but instrumenting events belongs in your SDK and data pipeline, not in a read assistant. Orbit treats Amplitude purely as a read source. This line is deliberate, not a missing feature.
Create or edit charts and dashboards
Not built — by designBuilding charts, dashboards, and cohorts stays in Amplitude's UI. Orbit reads the analyses and reasons over the numbers; it does not author your Amplitude workspace. A data source is for reading, and Orbit keeps to that.
The short version: with your read key, Orbit can pull the whole engagement picture — cohorts, event volume, funnels, retention, a single user's activity — and reason over it. Where an API is asynchronous or windowed, Orbit does the round-trip and names the edge. The one thing it won't do is write: no event ingestion, no chart authoring. Amplitude stays your source of truth, unchanged.
The engagement read it was built for.
This is where an Amplitude read key earns its place. Point Orbit at your project and ask Claude to answer the questions a lifecycle owner asks before designing anything — except it reads the real numbers instead of asking you to paste a chart.
- Which cohort is slipping.Orbit reads a behavioural cohort's definition and sizes it, then reads the retention curve for its members — so “the week-two drop-off is getting worse” becomes a number with a shape, not a hunch. That is the input a win-back or a re-engagement nudge should be built from.
- Where the funnel leaks. Orbit reads your activation or onboarding funnel through the Funnel Analysis endpoint and reports the drop-off step by step. If most users fall out between
sign_upandfirst_action, that is where an onboarding email sequence has to do its work — and now Claude knows it from the data. - What retention actually looks like. Orbit reads the return-rate curve for a start and return event, so the D1, D7, and D30 numbers are real ones. That decides whether the honest move is a retention programme at all, or a fix further up the funnel first.
None of this needs write access — it never could. The whole read runs on your Amplitude key and secret against the Dashboard REST API, which is exactly how it should be.
How to connect it.
Two values, both read-only by nature. In Amplitude, open your project's settings and copy the API Key and the Secret Key. Paste them into Orbit's config and you're connected — those credentials authenticate the Dashboard REST API, which are the read surface.
- The key and secret are per project.They scope Orbit to one Amplitude project's data — nothing broader. If you run separate projects for separate products, you connect the one you want Claude reading, and Orbit names it back to you so there's no confusion about the source.
- There is no write path to turn on.Unlike an ESP, there's no scope to widen later for sending or building — Orbit reads Amplitude and only reads it. The posture isn't enforced by a permission you granted; it's what a data-source integration is.
The credentials are stored as secrets and never leave your machine in plain text. That's the whole setup — no OAuth dance, no app to install on Amplitude's side. If a read hits an asynchronous or windowed endpoint, Orbit tells you it's waiting or paging rather than returning a quiet partial.
A data source, not a sending platform — and why that matters.
Amplitude is where you measure. You don't send a campaign through it, and this integration keeps to that boundary: it reads the engagement and retention truth, and the lifecycle building then happens where Orbit runs deepest — email-first, and deepest on Braze, where a handful of Orbit's tools are built around concepts like Canvas flows, Content Blocks, and the media library that only exist there.
Being honest about that is the point. Amplitude is a read integration — a source Claude reasons over — and the depth of Orbit's lifecycle work lives on the sending side, not here. What the Amplitude read gives you is the evidence: connect it, and the win-back you design in your ESP starts from the cohort that's actually slipping, not the one you guessed at.
The half that isn't about the API at all.
Reading Amplitude is the connection. The reason to bother is what Claude does with what it read. Orbit ships 79 lifecycle skills — structured protocols for the actual jobs: laddering a win-back off a slipping cohort, building an onboarding sequence against the funnel step that leaks, scoring a subject line. The Amplitude numbers become the input those protocols run on, instead of an assumption.
Underneath sit 130tools, including its own cohort-retention and RFM analysers — so once Orbit has read the raw events, it can band and segment them itself and hand the result to the message it's about to help you build. Amplitude gives you the ground truth about what customers do. Orbit is the practitioner reading it, then turning it into the next thing you send.
Is this for you?
This is for the lifecycle or growth owner whose engagement truth lives in Amplitude and who is tired of screenshotting charts into the chat. If you plan retention and win-back work off cohorts, funnels, and return curves, Orbit hands you a Claude that reads them directly through a key you scoped to one project. It's a weaker fit if you want a tool that sends — Amplitude isn't that, and Orbit won't pretend it is. It doesn't write to Amplitude and it won't run your programme for you. What it gives you is a Claude that starts from the real numbers instead of a description of them, and a straight answer about what a product-analytics API can and can't read — which is rarer than it should be.
Try it.
Orbit is free — every skill and tool included, no seats and no subscription. Copy your Amplitude key and secret, paste them in, and Claude goes from reasoning about a screenshot to reading the real cohort the same afternoon.
Where you act on what you read.
Amplitude tells you what's happening. These are the platforms where Orbit helps you do something about it:
Frequently asked.
What is an MCP for Amplitude?
An MCP — Model Context Protocol, an open standard from Anthropic — gives Claude real tools instead of general knowledge. Connected to Amplitude through Orbit with your own API key and secret, Claude can read your behavioural cohorts, event volume, funnel conversion and retention curves — the engagement truth your lifecycle work depends on. These are AGGREGATE reads: Orbit deliberately does not pull per-user rows or raw event exports. It is not an official Amplitude product; it is an independent MCP that calls Amplitude's Dashboard REST API with the credentials you provide, and it reads rather than writes.
Is the Amplitude connection read-only?
Yes. Orbit treats Amplitude as a data source, not a target it mutates. It uses your project API key and secret against Amplitude's Dashboard REST API — the analytics-read surface — to pull cohorts, event segmentation, funnel conversion and retention. It does not instrument events, edit charts, or change anything in your Amplitude workspace. The key and secret are stored as secrets and the calls run from your machine.
What can Orbit read from Amplitude?
The engagement picture a lifecycle decision actually needs. Orbit reads your behavioural cohorts and their definitions, event volume and segmentation (an event broken down by any property over a date range), funnel conversion and drop-off across an ordered sequence of up to ten events, and retention curves. Together that is the answer to which cohort is slipping, where the onboarding funnel leaks, and how the return curve actually looks — read straight from Amplitude rather than described from a screenshot. One honest limit on retention: Amplitude's API defines the start and return events as fixed states — new or active users returning — so a retention curve keyed to a custom event is not something its API offers; Orbit models that as two event reads instead.
Can Orbit export raw Amplitude events?
No, and that is deliberate. Amplitude publishes an Export API for raw per-event data, but Orbit does not call it and ships no per-user read of any kind. Lifecycle decisions are made on aggregates — which cohort is slipping, where the funnel leaks, how the return curve bends — and pulling a raw event firehose or an individual's timeline into an AI session is a privacy cost with no matching benefit. If you need raw events, export them from Amplitude yourself and point Orbit's analysis at the file.
Can Orbit send events or build charts in Amplitude?
Not at all, and that is deliberate. Amplitude does have an HTTP ingestion API, but instrumenting events belongs in your SDK and data pipeline, not in an analytics assistant — so Orbit doesn't write events. It also doesn't create or edit charts, dashboards, or cohorts in your Amplitude workspace; that authoring stays in Amplitude's UI. Orbit reads the analyses and reasons over the numbers. Reading them while leaving the workspace untouched is the whole point of the integration.
Is Amplitude where a lifecycle programme runs?
No — Amplitude is where you measure, not where you send. It is the product-analytics layer that tells you what customers actually do: which cohort is retaining, where activation stalls, what the return curve looks like. The sends themselves live in your ESP or CDP. Orbit reads Amplitude to inform that work, then does the lifecycle building where it runs deepest — email-first, and deepest on Braze. Think of Amplitude as the evidence and Orbit as the practitioner reading it before designing the next nudge.