Menu

Mattering Automations Amplitude integration

Connect Amplitude to Mattering Automations: real-time and active user counts, event segmentation, funnels, retention, revenue LTV, user activity streams, annotations, cohorts, and event ingestion as workflow steps, authenticated with your project's API key and secret key.

The Mattering Automations Amplitude integration adds Amplitude to your automation canvas: read real-time active users, daily, weekly, and monthly actives, user composition, and session metrics, segment events with metrics, formulas, and group-bys, run funnel and retention analyses, pull revenue LTV cohorts, look up individual users and their event streams, create chart annotations as release markers, read the taxonomy, manage behavioral cohorts, and send events, user properties, and group properties into Amplitude from workflows.

Setup takes a few minutes: copy the API key and secret key from your Amplitude project's settings, attach them as a credential in Mattering, and test the connection. This guide walks through each step and ends with the full node reference.

The safety posture is simple to state: of the 23 nodes, 17 are pure reads and the 6 writes only add or update, so nothing in this integration can delete or destroy analytics data. Amplitude: Get Real-Time Active Users doubles as the connection test: it takes no parameters, works on every Amplitude plan, and is one of the cheapest reads on the query budget.

Before you start

  • An Amplitude account with a project. Amplitude's free Starter plan includes the API key and secret key pair, the dashboard query API, cohorts, and ingestion, so a free project is enough to test with.
  • Access to the project's settings in Amplitude (Settings, then Projects), where the API key and secret key are shown.
  • A Mattering workspace with access to the Automations app.
  • A project on Amplitude's US data residency. This version of the integration covers the US hosts only; projects on Amplitude's EU data center are not supported yet.

Find your Amplitude project's API key and secret key

Mattering authenticates to Amplitude with the project's API key and secret key, sent as HTTP Basic auth on every query request: the API key is the username and the secret key is the password. The keys are project-scoped, so one credential reads and writes exactly one Amplitude project.

In Amplitude, open Settings, go to Projects, and select the project you want to automate.
Copy the API Key and the Secret Key shown in the project's settings.
Keep the pair together: the credential stores the API key as the username and the secret key as the password.
The keys belong to one project, so queries and ingestion both land on that project alone. To automate several Amplitude projects, create a separate credential for each. The secret key authorizes the full query surface, including per-user event streams, so treat it like any other secret.

Connect Amplitude to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Amplitude from the list.
Click Create new credential, enter the API key as the username and the secret key as the password, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection: Mattering calls Amplitude's real-time active users endpoint and confirms the pair authenticates. The check works on every Amplitude plan and is one of the cheapest reads on the query budget.
Click Connect. All 23 Amplitude nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: an Amplitude section should list the query and action nodes. Drop Amplitude: Get Real-Time Active Users onto the canvas and run a test step. It takes no parameters and is a safe, read-only call; a successful response returns active user counts in five-minute buckets for today and yesterday. If it fails with a 401, recheck that the API key is the username and the secret key is the password.

To confirm the query surface, run Amplitude: List Tracked Events, which lists every event the project tracks with weekly totals, then Amplitude: Segment an Event against one of those events with a date range of a few days. Everything in the verify path is read-only, and nothing anywhere in this integration can delete Amplitude data. Keep test ranges short: dashboard queries share a cost-based budget, and cost grows with the date range.

Node reference

23 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 17

Amplitude: Get Active or New User Counts

amplitude_query_active_users

Get daily, weekly, or monthly active or new user counts over a date range, optionally segmented and grouped by a property: the DAU/WAU/MAU read. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Get Average Session Length

amplitude_query_average_session_length

Get the average session length in seconds for each day in a date range. Session lengths are capped at one day. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Get Average Sessions per User

amplitude_query_sessions_per_user

Get the average number of sessions per user for each day in a date range: an engagement-depth companion to the DAU read. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Get Real-Time Active Users

amplitude_get_realtime_active_users

Get active user counts in five-minute buckets for today and yesterday: the live pulse of the product. Takes no required parameters, so it doubles as the credential health check for the whole connector. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Get Revenue LTV

amplitude_query_revenue_ltv

Get revenue lifetime value cohorts: for users first seen on each date, cumulative revenue per user (ARPU), per paying user (ARPPU), total revenue, or paying-user counts at 1, 7, 14, 30, 60, and 90 days out. Only returns data if the project tracks revenue. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Get User Composition by Property

amplitude_query_user_composition

Break the active user base down by one property's values over a date range, e.g. how many users per country, platform, app version, or plan. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Get a User's Event Stream

amplitude_get_user_activity

Get one user's profile summary (first/last seen, event count, user properties) and their recent event stream by Amplitude ID (find it with the Search for a User node). Event streams are personal data and persist in execution records; keep limit modest. Budget: 360 queries per hour, 10 concurrent (shared with user search).

Amplitude: List Chart Annotations

amplitude_list_annotations

List the project's chart annotations (release markers, campaign launches, incidents), optionally filtered by category, chart, or date window. Each annotation carries its id, label, timestamps, and category.

Amplitude: List Cohorts

amplitude_list_cohorts

List the project's behavioral cohorts with id, name, size, definition metadata, and timestamps. Note: downloading a cohort's MEMBER LIST is a separate async export job this connector deliberately does not model (the file can be millions of rows); manage membership with the upload and membership nodes instead. Cohort API budget: 60 requests per 10 minutes.

Amplitude: List Event Properties (Taxonomy)

amplitude_list_event_properties

Read the planned properties of one event type (or the shared properties when no event type is given): names, value types, enum values, and required flags. Plan gate: requires an Amplitude Enterprise plan.

Amplitude: List Event Types (Taxonomy)

amplitude_list_event_types

Read the project's planned event taxonomy: every event type with its category, description, and visibility flags, for schema governance and discovery. Plan gate: the Taxonomy API requires an Amplitude Enterprise plan; other plans get a permission error, not an auth failure.

Amplitude: List Tracked Events

amplitude_list_events

List every event tracked in the project with its display name, weekly totals, and visibility flags: the schema discovery step before building segmentation or funnel queries. Hidden events are not returned. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: List User Properties (Taxonomy)

amplitude_list_user_properties

Read the project's user property dictionary: standard properties (device_id, user_id, amplitude_id, country and friends) plus custom properties (prefixed gp:), with types and descriptions. Plan gate: requires an Amplitude Enterprise plan.

Amplitude: Run a Funnel Analysis

amplitude_query_funnels

Compute funnel conversion across an ordered list of events: step-by-step and cumulative conversion rates, raw counts, and median/average transition times between steps. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Run a Retention Analysis

amplitude_query_retention

Get cohort retention: for users who did a start event, how many came back and did a return event in each subsequent period. Supports n-day (the default), rolling, and bracket retention modes. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Amplitude: Search for a User

amplitude_search_users

Find a user's Amplitude ID by searching with an Amplitude ID, a device ID, a user ID, or a user ID prefix. Feed the returned amplitude_id into the Get User Activity node. Budget: 360 queries per hour, 10 concurrent (shared with user activity).

Amplitude: Segment an Event

amplitude_query_event_segmentation

The workhorse analytics read: count one event (optionally compared against a second) over time with a chosen metric (uniques, totals, pct_dau, average, property sums or averages, or a formula), filtered by segments and grouped by up to two properties. Dashboard REST budget: cost-based, 108,000 cost per hour and at most 5 concurrent requests shared across all Amplitude query nodes; cost grows with the date range, filter conditions, and group-bys, so keep ranges tight.

Action nodes 6

Amplitude: Add or Remove Cohort Members

amplitude_update_cohort_membership

Incrementally ADD or REMOVE members of an existing uploaded cohort without re-uploading the whole list. Reversible by construction: every ADD has a matching REMOVE. Cohort API budget: 60 requests per 10 minutes.

Amplitude: Create a Chart Annotation

amplitude_create_annotation

Add a chart annotation, e.g. mark a deploy, a campaign start, or an incident so it shows on Amplitude charts at that timestamp. Reversible: annotations can be deleted in the Amplitude UI or via the annotations API.

Amplitude: Set Group Properties (Group Identify)

amplitude_group_identify

Set properties on a GROUP (e.g. an organization or account) rather than a user, keyed by group type and value. Group analytics features require an Amplitude plan with Accounts enabled. $set overwrites existing values for the named properties. Auth note: this endpoint takes only the project API key (sent in the request body); the runner injects it from the connector credential's username, and the secret key is never sent to the ingestion host.

Amplitude: Set User Properties (Identify)

amplitude_identify_user

Update a user's properties without sending an event, using Amplitude's Identify operations ($set, $setOnce, $add, $append, $unset and friends). Careful: $set OVERWRITES the existing value of each property it names; changes apply to future events only, never retroactively. Budget: 1,800 property updates per hour per user. Auth note: this endpoint takes only the project API key (sent in the request body); the runner injects it from the connector credential's username, and the secret key is never sent to the ingestion host.

Amplitude: Track Events (HTTP V2)

amplitude_track_events

Send events INTO Amplitude from an automation (server-side tracking). Each event needs an event_type plus a user_id or device_id (5+ characters); include time (epoch ms) and an insert_id so retries deduplicate. Up to 2,000 events per request, 1 MB max payload. Note: ingested events cannot be deleted through this connector, so point test runs at a throwaway project or a clearly named test event. Auth note: this endpoint takes only the project API key (sent in the request body); the runner injects it from the connector credential's username, and the secret key is never sent to the ingestion host.

Amplitude: Upload a Cohort

amplitude_upload_cohort

Create (or replace, via existing_cohort_id) a static cohort from a list of user identifiers, e.g. sync a customer list from another system into Amplitude for targeting and analysis. Up to 100,000 identifiers per request. Reversible: an uploaded cohort can be deleted in the Amplitude UI. Cohort API budget: 60 requests per 10 minutes.

Using the integration

On the automation canvas

Amplitude nodes chain with every other node: a scheduled Amplitude: Run a Retention Analysis and Amplitude: Run a Funnel Analysis pair can land a weekly digest as a report task in Mattering Productivity, a churn-risk cohort refreshed with Amplitude: Add or Remove Cohort Members can drive follow-up tasks for the team, and query results can update records in a Mattering database. There is no inbound Amplitude trigger in this integration, so the pattern for reacting to analytics is a scheduled sweep: query on a schedule, compare against a threshold or the prior period, and route what changed.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and Matter can read the live user pulse, segment events, run funnels and retention, and look up individual users through the same nodes your workflows use. With 17 of 23 nodes being pure reads and no destructive node at all, this is one of the safest integrations to hand an agent; Amplitude: List Tracked Events and, on Enterprise plans, the taxonomy reads let it learn the project's schema before querying.

The cost-based query budget

Amplitude's dashboard query API meters by cost rather than a flat request count: the shared budget is 108,000 cost per hour with at most 5 concurrent requests across all Amplitude query nodes on the credential, and a query's cost grows with its date range, filter conditions, and group-bys. Keep date ranges tight and group-bys purposeful, especially on scheduled sweeps. Amplitude: Search for a User and Amplitude: Get a User's Event Stream have their own separate budget of 360 queries per hour at 10 concurrent, and the cohort nodes share a budget of 60 requests per 10 minutes.

Sending data in on the same credential

Amplitude: Track Events (HTTP V2) sends events into Amplitude from automations, up to 2,000 events per request; include an insert_id on each event so retries deduplicate. Ingested events cannot be deleted through this integration, so point test runs at a throwaway project or a clearly named test event. Amplitude: Set User Properties (Identify) updates a user's properties without sending an event, and Amplitude: Set Group Properties (Group Identify) does the same for a group; on both, the set operation overwrites the existing values of the properties it names, and changes apply to future events only, never retroactively. Amplitude's ingestion endpoints take only the API key, sent in the request body: the integration injects that half of the credential server-side, and the secret key is never sent to the ingestion host, so there is nothing to configure.

Users one at a time, and where raw export went

Amplitude: Search for a User translates an Amplitude ID, device ID, user ID, or user ID prefix into the numeric Amplitude ID, and Amplitude: Get a User's Event Stream returns that user's profile summary and recent events. Event streams are personal data and persist in execution records, so keep the limit modest and pull only what the investigation needs. The raw Export API is deliberately not part of this integration: it returns zipped archives of up to 4 GB per request with no row limit, which cannot flow through workflow outputs honestly. Aggregate questions belong to Amplitude: Segment an Event, bounded per-user pulls to the event stream node, and bulk pipelines to Amplitude's own export destinations.

Cohorts in both directions

Amplitude: List Cohorts enumerates the project's behavioral cohorts with ids, names, and sizes. Amplitude: Upload a Cohort creates a static cohort from a list of user identifiers, up to 100,000 per request, and pointed at an existing cohort id it replaces that cohort's membership. Amplitude: Add or Remove Cohort Members adjusts membership incrementally and is reversible by construction, since every add has a matching remove. Downloading a cohort's member list is deliberately not modeled: it is an async export job whose file can run to millions of rows, with the same unbounded-output problem as the raw export.

Troubleshooting

Test Connection fails with a 401
The keys are wrong, swapped, or picked up stray whitespace when pasted. The API key must be the username and the secret key the password; both come from the project's settings in Amplitude (Settings, then Projects). Also confirm the keys belong to the project you mean to automate, since every Amplitude project has its own pair.
The taxonomy nodes return a permission error
That is a plan gate, not a credential problem. Amplitude: List Event Types (Taxonomy), Amplitude: List Event Properties (Taxonomy), and Amplitude: List User Properties (Taxonomy) require an Amplitude Enterprise plan; other plans get a permission error while every other node on the same credential works. For schema discovery without the Enterprise gate, use Amplitude: List Tracked Events.
Queries fail or return empty data even though the project clearly has data
Check the project's data residency. This version of the integration speaks only to Amplitude's US hosts, so a project stored on Amplitude's EU data center will fail to authenticate or return empty results against it. There is no workaround in the current version; EU host support is a candidate for a future release.
Queries start failing with rate limit errors
Dashboard queries share a cost-based budget of 108,000 cost per hour with at most 5 concurrent requests, and a query's cost grows with its date range, filter conditions, and group-bys. Tighten date ranges, drop unneeded group-bys, and space out scheduled sweeps. The user lookup nodes have their own budget of 360 queries per hour, and the cohort nodes 60 requests per 10 minutes, so heavy use of one surface does not have to starve the others.
Get a User's Event Stream returns nothing for a user who exists
The node wants the numeric Amplitude ID, not a user id or device id. Run Amplitude: Search for a User first: it accepts an Amplitude ID, device ID, user ID, or user ID prefix and returns the amplitude_id the activity node needs. Remember the result is one person's event stream and persists in the execution record, so keep the limit modest.
Get Revenue LTV returns empty results
The project does not track revenue. Amplitude: Get Revenue LTV only returns data when revenue events are instrumented in the project; nothing about the credential or the node is wrong. The user count metrics in the same response shape still populate, but the revenue columns stay empty until revenue tracking exists.
Properties set with Identify did not change past events
That is how Amplitude works: property changes made through Amplitude: Set User Properties (Identify) apply to future events only, never retroactively. Also note that the set operation overwrites the existing value of each property it names, and updates are budgeted at 1,800 property updates per hour per user. If group properties are rejected instead, check the plan: Amplitude: Set Group Properties (Group Identify) requires an Amplitude plan with the Accounts feature enabled.
A query node rejects its start or end date
Request dates are eight digits, YYYYMMDD, for example 20260801, even though Amplitude's responses come back with ISO-formatted dates. Reformat the value on the node, and if the date comes from an upstream step's output, convert it before passing it in rather than forwarding the ISO string.

Amplitude is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products