Mattering Automations Umami integration
Connect Umami to Mattering Automations: website stats, pageview and event series, ranked breakdowns, realtime activity, sessions and properties, seven runnable reports, website management, teams and tracked links as workflow steps, on Umami Cloud or a self-hosted install.
The Mattering Automations Umami integration puts Umami's analytics API on your automation canvas: summary stats, pageview and event time series, ranked one-dimension breakdowns, live visitor activity, sessions and their properties, event and property discovery, seven runnable reports covering breakdown, goal, funnel, journey, retention, attribution and UTM, plus website management, teams and tracked short links. 43 nodes, 35 that read and 8 that act.
Umami ships in two deployments and this integration supports both from one node set. Umami Cloud authenticates with an API key created under Settings then API keys. A self-hosted install authenticates with your dashboard username and password, which the connector exchanges for a token at Umami's login endpoint and refreshes automatically. Both send an Authorization Bearer header. Every documented path below the base URL is identical across the two, so only the base and the source of the token differ.
One correction is worth making up front, because it is repeated widely outside Umami's own documentation. Umami Cloud does NOT use an x-umami-api-key header. The vendor's own curl example sends Authorization with Bearer, and that is what this integration sends.
Before you start
- An Umami account, either on Umami Cloud or a self-hosted install you can sign in to.
- For Umami Cloud: an API key, created under your profile then Settings then API keys then Create key. API access is a paid Cloud feature. Umami's pricing page lists it from the Pro plan up, and the free Hobby plan covers one website, up to 100K events per month and six months of retention without it, so a Cloud credential needs Pro or above. Confirm the current plan details on Umami's pricing page. Self-hosting has no such gate.
- For self-hosted: your install's root URL and the username and password you use for the dashboard. The URL must be https. Plain http is refused rather than upgraded, because a password sent in the clear is interceptable. Self-hosting Umami is free and open source.
- At least one website already set up in Umami, or the intent to create one. Umami: Create Website works from the canvas, and the verify path below reads cleanly either way.
- If your sites live under a team, know that: Umami's ordinary website list HIDES team-owned websites unless you ask for them, which is the most common reason a picker looks empty.
- Two surfaces are gated by deployment rather than by plan, and the gate is the vendor's. Umami states that its users and admin endpoints are not available for Umami Cloud and that they require an admin account on a self-hosted install, so this integration does not ship them at all. Revenue reporting and the web-vitals performance report depend on opt-in capture and are not shipped either.
- A Mattering workspace with access to the Automations app.
Create an Umami credential
The credential starts with an explicit deployment choice rather than an inference from which fields you happened to fill, because a wrong guess here would surface as a confusing provider error instead of a clear one. Pick the deployment, then fill in only that half.
Connect Umami to Mattering
Verify it works
Open any automation canvas and check the palette: an Umami section should list the read and action nodes. Drop Umami: List Websites onto the canvas and run a test step. It is the natural first node here because nearly every other node needs a website id and takes it from a picker sourced from this lister, showing each website by NAME with its domain beside it so two sites called Marketing are distinguishable.
If the list comes back empty or shorter than your dashboard, turn on the include-teams option and run it again. Umami hides team-owned websites from this list by default, which is the single most common cause of a picker that looks broken. You can also reach them through Umami: List Teams and then Umami: List Team Websites.
Now prove a reporting node. Drop Umami: Get Website Stats onto the canvas, choose a website from the picker, and set the window. Note the encoding while you are here: on this family of nodes the window is Unix time in MILLISECONDS, not a date. A successful run returns pageviews, visitors, visits, bounces and total time for the range.
Finally, run Umami: Get Active Visitors. It is the cheapest read in the connector, takes only a website, and returns a single current number, which makes it the node to point any live poll at. Everything in this verify path is read-only, so it cannot reach the four destructive nodes and is safe to re-run whenever you rotate the credential.
Node reference
43 nodes, generated from the connector itself so this reference always matches what ships.
Read and query nodes 35
Umami: Get Active Visitors
umami_get_active_visitors
How many visitors are on the site right now, as a single count at data.visitors. Takes no date range: it is always "now", which makes it the cheapest possible poll for a live counter, a traffic-spike alert, or a status dashboard tile. Read-only and free to call.
Umami: Get Current Account
umami_get_me
Read the account behind the stored credential: username, role, and whether it is an admin. The only zero-parameter authenticated read in the Umami API, which makes it this connector's credential health check on BOTH deployments - on Cloud it validates the API key, and on a self-hosted install it proves the username and password exchanged cleanly for a token. Free to call and read-only.
Umami: Get Event Data Stats
umami_get_event_data_stats
How much custom event data a website is collecting in a window: the number of distinct events, distinct properties, and total property records. A volume health check - use it to spot the day a tracking change stopped sending properties.
Umami: Get Event Stats
umami_get_event_stats
Summary counts for custom events across a window: total events fired, how many visitors and visits produced them, and how many DISTINCT event names were seen. Optionally returns a comparison period alongside. The comparison numbers describe a different window and must not be merged into the requested one.
Umami: Get Events Series
umami_get_events_series
Custom events counted over time, one row per event name per bucket: {x: event name, t: bucket timestamp, y: count}. Use it to chart signups, button clicks or any tracked event against traffic. Pick the bucket width with unit and align the boundaries with timezone.
Umami: Get Expanded Metrics Breakdown
umami_get_expanded_metrics
The same one-dimension breakdown as Get Metrics Breakdown, but every row carries the full measure set instead of a single count: pageviews, visitors, visits, bounces and totaltime per value. This is the node to use when you want to rank by one measure and report another - for example the operating systems with the most visits but the worst bounce behaviour. Bounce rate and average duration are not returned; derive them per row as bounces/visits and totaltime/visits.
Umami: Get Metrics Breakdown
umami_get_metrics
Break a window down by one dimension and get the ranked list back: top pages, top referrers, browsers, countries, devices, UTM sources and more, as rows of {x: value, y: count}. Pick the dimension with type. Rows come back highest-first and are capped by limit, so this answers "what are my top N" rather than "give me everything".
Umami: Get Pageviews Series
umami_get_pageviews_series
Pageviews and sessions bucketed over time, as two parallel series at data.pageviews and data.sessions. Each row is {x: bucket timestamp, y: count}. This is the node for a traffic chart: pick the bucket width with unit and align the boundaries with timezone. Because both series use the same column name for their value, a consumer must keep them apart by which array they came from.
Umami: Get Realtime Activity
umami_get_realtime
Everything happening on the site in the last 30 minutes in one call: live totals, per-minute view and visitor series, the individual recent events with their country, browser and page, and counts by country, URL and referrer. The window is FIXED at the trailing 30 minutes and takes no parameters, so it always self-advances and cannot be asked for a historical period. Ideal for a live wall display or a traffic-spike alert; useless for reporting, which wants Get Website Stats.
Umami: Get Report
umami_get_report
Fetch one saved report definition by id, including the parameters it was built with. Pair it with the matching run node to execute a team's saved analysis on a schedule rather than re-specifying it in the workflow.
Umami: Get Session
umami_get_session
One session's full profile by id: device and location attributes, when it started and last acted, and its totals for visits, views, events and time on site. Use it after List Sessions or after reading a session id off an event.
Umami: Get Session Activity
umami_get_session_activity
The ordered clickstream for one session: every pageview and custom event with its timestamp, URL path, query string, referrer and event name. This is what makes a session readable as a story rather than a row of totals - use it to reconstruct the path a converting visitor took.
Umami: Get Session Stats
umami_get_session_stats
Session-level totals for a window - pageviews, visitors, visits, distinct countries and events - each returned as an object with a value key rather than as a bare number. The shape is worth knowing before you wire it up: read data.visitors.value, not data.visitors.
Umami: Get Team
umami_get_team
Fetch one team by id, with its full member list and each member's role. Use it to audit who can see a client's analytics before sharing a dashboard.
Umami: Get Website
umami_get_website
Fetch one website's configuration by id: its name, tracked domain, share id, owning user or team, and the timestamp of the last data reset. Read-only and free to call.
Umami: Get Website Date Range
umami_get_website_daterange
The first and last timestamps for which this website has any data. Use it before a backfill so a workflow asks only for windows that can contain rows, instead of walking months of empty days. Read-only, takes no parameters besides the website.
Umami: Get Website Stats
umami_get_website_stats
The headline numbers for a window: pageviews, unique visitors, visits, bounces and total time on site, as one summary object. This is the node behind "how did last week go" reporting. Note what the API does and does not return: bounces and totaltime are RAW COUNTS, not the bounce rate and average visit duration the Umami dashboard shows - those are derived as bounces/visits and totaltime/visits, so compute them after any aggregation, never before. The comparison object, when present, describes a DIFFERENT period and must not be merged into the requested one.
Umami: List Event Properties
umami_list_event_properties
Which custom properties your tracked events actually carry, and how often, as rows of {eventName, propertyName, total}. Run this first when you do not know an install's event schema: it tells you what property names exist before you ask for their values.
Umami: List Event Property Values
umami_list_event_property_values
The distinct values one custom property took, with a count for each: {value, total}. Pair it with List Event Properties, which tells you the property names this install actually collects. Use it to turn free-form event data into a chart - which plan names signups chose, which experiment variants fired.
Umami: List Events
umami_list_events
The individual event and pageview records in a window, paginated: each row carries its session id, timestamp, URL path, page title, event name, and the visitor's country, device and browser. This is the raw feed rather than a rollup - use it to drive per-event automations, and use Get Event Stats when you want the numbers instead.
Umami: List Links
umami_list_links
List your Umami tracked short links, each with its name, destination URL and slug. Umami's link shortener records a visit when someone follows a link, so these are trackable campaign URLs rather than plain redirects.
Umami: List Reports
umami_list_reports
List the saved report definitions for a website - their names, types and stored parameters. These are the reports someone built in the Umami UI; listing them lets an automation discover what analysis a team already cares about instead of hard-coding one.
Umami: List Session Properties
umami_list_session_properties
Which session-level properties this website collects, with a session count for each - the identify()-style attributes attached to a visitor rather than to a single event. Run it before List Session Property Values to learn an install's property names.
Umami: List Session Property Values
umami_list_session_property_values
The distinct values one session property took, with a session count for each. Use it to segment an audience by the attributes your own site sets - plan tier, logged-in state, experiment cohort - without ever storing a cookie.
Umami: List Sessions
umami_list_sessions
Individual visitor sessions in a window, paginated, each with its browser, OS, device, screen size, language, country, region and city, plus how many visits and views it produced and when it started and ended. Privacy note: Umami collects no cookies and no personal data, so a session is an anonymous device fingerprint, not a person.
Umami: List Team Websites
umami_list_team_websites
List the websites owned by one team, with domain and creator. Use it to iterate an agency's client sites and run the same weekly report against each without hard-coding a list of ids.
Umami: List Teams
umami_list_teams
List the teams this account belongs to, each with its members, roles and website count. Team ids feed the team picker on Umami: Create Website and Umami: List Team Websites, so this is the lister behind both.
Umami: List Websites
umami_list_websites
List every website the credential can see, each with its id, name and tracked domain at data.data. This is the connector's canonical website lister: every other node's website picker reads from it, so the id a workflow uses always comes from the vendor rather than from a pasted string. Paginated, with a server-side search over name and domain.
Umami: Run Attribution Report
umami_run_attribution_report
Credit conversions to the channels that produced them, under a first-click or last-click model: referrers, paid ads and every UTM field, plus window totals. This is the "which campaign actually worked" node. Attribution is model-dependent by nature, so state the model when you report the number. This report is computed across the WHOLE window and cannot be split: running it for January and again for February does not combine into January-February, because a visitor's path can cross the boundary. Roll the window forward freely; never chunk it and add the pieces up.
Umami: Run Breakdown Report
umami_run_breakdown_report
Cross-tabulate a window by SEVERAL dimensions at once - operating system by country, referrer by device - with the full measure set on every row: views, visitors, visits, bounces and totaltime. This is the one report that goes beyond what the single-dimension metrics nodes can answer, and unlike them it is not a truncated top-N list. Read-only despite being a POST: the body carries the query.
Umami: Run Funnel Report
umami_run_funnel_report
Run a multi-step conversion funnel over a window and get per-step visitor counts, drop-off and remaining share. Define the steps as pages or events and set how many days a visitor has to complete the journey. This report is computed across the WHOLE window and cannot be split: running it for January and again for February does not combine into January-February, because a visitor's path can cross the boundary. Roll the window forward freely; never chunk it and add the pieces up.
Umami: Run Goal Report
umami_run_goal_report
Measure one conversion goal over a window: how many of the period's visitors reached a given page or fired a given event, against the total. Returns {num, total}. Use it for a weekly conversion digest or an alert when a goal drops.
Umami: Run Journey Report
umami_run_journey_report
Discover the actual paths visitors take, rather than testing one you guessed: returns the most common ordered sequences of pages of a given length, with how many visitors walked each. Anchor it at a starting page, and optionally at an ending one. This report is computed across the WHOLE window and cannot be split: running it for January and again for February does not combine into January-February, because a visitor's path can cross the boundary. Roll the window forward freely; never chunk it and add the pieces up.
Umami: Run Retention Report
umami_run_retention_report
Cohort retention: for each day's first-time visitors, how many came back on each subsequent day, as a count and a percentage. The question a pageview chart cannot answer - whether the traffic you bought last month is still reading. This report is computed across the WHOLE window and cannot be split: running it for January and again for February does not combine into January-February, because a visitor's path can cross the boundary. Roll the window forward freely; never chunk it and add the pieces up.
Umami: Run UTM Report
umami_run_utm_report
All five UTM dimensions for a window in one call - source, medium, campaign, term and content - each with its view count. The node for a campaign-performance digest, without running five separate breakdowns.
Action nodes 8
Umami: Create Link
umami_create_link
Create a tracked short link, e.g. one per campaign send or per social post, so the clicks land in the same analytics as everything else. Reversible: a link created by mistake can be deleted, and while nothing has followed it yet there is nothing to lose.
Umami: Create Report
umami_create_report
Save a report definition so it appears in the Umami dashboard alongside the ones people built by hand - useful for provisioning a standard set of funnels or goals on every new client website. Reversible: a report created by mistake can be deleted, and no collected data is involved either way.
Umami: Create Website
umami_create_website
Add a website to Umami and get back its id and tracking configuration, e.g. when provisioning analytics for each new client site. Reversible: a website created by mistake can be deleted, and while it has no traffic yet there is nothing to lose by doing so.
Umami: Delete Link
umami_delete_link
DESTRUCTIVE AND IRREVERSIBLE. Deletes a tracked short link. What is lost: the slug stops resolving IMMEDIATELY, so every already-published copy of that URL - in a sent email, a printed QR code, a social post you cannot edit - starts failing for anyone who clicks it, and the link's recorded click history goes with it. There is no trash and no undo. Re-creating a link with the same slug restores the redirect but not the history. Deleting a link you have already distributed is not reversible by re-creating it fast.
Umami: Delete Report
umami_delete_report
DESTRUCTIVE AND IRREVERSIBLE. Deletes a saved report definition. What is lost: the report's name, description and stored parameters - the analysis someone configured - permanently, with no trash and no undo, and it disappears from every dashboard that showed it. What is NOT lost: no collected analytics data is touched, and the identical report can be rebuilt with Umami: Create Report if you still hold its parameters, so read it with Umami: Get Report first if you might want them back.
Umami: Delete Website
umami_delete_website
DESTRUCTIVE AND IRREVERSIBLE. Deletes the website AND every pageview, session, event and session property ever collected for it. What is lost: the whole analytics history, the website id itself, and every saved report and share link scoped to it - permanently, with no trash and no undo. Anything referencing the id (a dashboard, another automation, a Mattering Analytics dataset) breaks rather than degrades. The tracking script keeps firing from your pages and its hits are simply discarded. Re-creating a website with the same domain gives a NEW id and starts from zero. If you only want to clear the data, use Umami: Reset Website Data instead.
Umami: Reset Website Data
umami_reset_website
DESTRUCTIVE AND IRREVERSIBLE. Deletes every pageview, session, event and session property ever collected for this website, while keeping the website row itself. What is lost: the entire analytics history, permanently - there is no trash, no undo, and analytics data cannot be re-collected because the visits already happened. What survives: the website id, its name and domain, its tracking script, its share link and its saved reports, all of which keep working against an empty dataset from this moment on. Use for clearing test traffic before a launch; never on a live site you have not exported first.
Umami: Update Website
umami_update_website
Change a website's name, tracked domain, public share id, or session-replay and heatmap settings. Only the fields you fill are sent, so this never blanks a setting you left alone. Reversible by sending the previous values back. Changing the DOMAIN does not move or delete existing data, but Umami stops accepting hits from the old hostname.
Using the integration
On the automation canvas
Umami nodes chain with every other node. A weekly schedule can run Umami: Get Website Stats and write the row into a Mattering database so a history builds itself, Umami: Get Metrics Breakdown can rank pages or referrers for the same window, and Umami: Run Funnel Report can turn a conversion question into a workflow step whose output feeds a condition. One value does most of the wiring: the website id, which is a picker on 32 fields across the connector, sourced from Umami: List Websites and searchable by name. Note there is no trigger node here: Umami publishes no webhooks, so anything that watches for a change is a scheduled poll rather than a subscription.
From AI assistants over MCP
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and Matter, the assistant built into the platform, can drive the same surface. An agent can answer how traffic did with Umami: Get Website Stats, explain it with Umami: Get Metrics Breakdown, check what is happening right now with Umami: Get Active Visitors, and answer the harder questions with the report nodes rather than by guessing. It can also discover what is available before it queries, using Umami: List Event Properties and Umami: List Event Property Values to find the real property names instead of inventing them. Umami publishes no MCP server of its own as of August 2026, so there is no vendor tool to weigh this against; what this integration adds over a chat session is that the same nodes run on a schedule with nobody present, chain with every other connector in one workflow, and hold the credential once in a shared workspace. Keep agents on the read nodes, and gate the four destructive ones.
Cloud and self-hosted, from one node set
The deployment choice on the credential is the only place the difference appears. On Umami Cloud the API key you stored IS the bearer token, sent straight through. On Self-hosted the connector logs in with your username and password at Umami's login endpoint, caches the returned token briefly, and replays a call once if it comes back rejected, so a token that expired without notice recovers by itself rather than failing your workflow. It retries once rather than in a loop, so a genuinely wrong password surfaces as a clear rejection instead of hammering the login endpoint. Because every documented path below the base is identical across the two deployments, nothing else changes: the same 43 nodes, the same pickers, the same outputs. Host normalization is forgiving in one direction only: a bare hostname, a trailing slash, or a pasted dashboard path all resolve to the same API root, while a plain http URL is refused rather than silently upgraded.
The two date encodings, and where each applies
This is the most common way a working configuration gets broken here, so it is worth reading once. The statistics, events and sessions nodes take their window as Unix timestamps in MILLISECONDS. The seven report-run nodes (Umami: Run Breakdown Report, Umami: Run Goal Report, Umami: Run Funnel Report, Umami: Run Journey Report, Umami: Run Retention Report, Umami: Run Attribution Report, Umami: Run UTM Report) take theirs as ISO 8601 date-times. One connector, two encodings, because that is what Umami's API does. A value copied from one family into the other is rejected or coerced into something wrong, and a workflow that templates a date string into a millisecond field looks fine in the panel and fails at run time. Every affected field says which encoding it wants.
Filters, and reading the response shapes
The reporting nodes take filters as one object rather than as twenty separate fields, and the connector flattens it onto the query the way Umami expects on the wire. Umami documents the filterable names: path, referrer, title, query, browser, os, device, country, region, city, language, hostname, tag, event, distinctId, the five UTM parameters, segment and cohort. Three response shapes are worth knowing before you write a path expression. Paginated lists (websites, sessions, events, reports, teams, links) nest their rows one level down, which is why the pickers read from that inner region. Umami: Get Session Stats nests every NUMBER one level down again, under a value key, while Umami: Get Website Stats returns the same measures flat, so a path that works on one will not work on the other. And Umami: Get Pageviews Series returns TWO parallel series, pageviews and sessions, whose rows both use the same column name, with nothing in the row saying which series it came from.
Which numbers may be added up
Worth settling before anyone builds a chart, because this is where analytics dashboards go quietly wrong. Pageviews, visits, bounces and total time are counts, so they add up across days and weeks. Visitors do not: it is a count of distinct people, and thirty daily unique counts is not the month's unique count on any platform. Bounce rate and average visit duration are not columns Umami returns at all; its dashboard derives them at read time from bounces over visits and total time over visits, so anything that claims to aggregate them directly is inventing data. Both are recoverable correctly AFTER aggregating, because their numerators and denominators are all additive, which is exactly why visits is worth storing even though nobody charts it. One more: Umami: Get Metrics Breakdown and Umami: Get Expanded Metrics Breakdown are RANKED and truncated at your limit, so they answer top N, and two months of top N does not recombine into the pair's top N.
The seven reports, and the windows that must not be split
The report nodes are where Umami earns its place in a workflow, because a funnel or an attribution question is what a person actually asks. Umami: Run Breakdown Report and Umami: Run UTM Report are the ranking-shaped ones. Umami: Run Goal Report measures a target. Umami: Run Funnel Report and Umami: Run Journey Report trace paths through the site. Umami: Run Retention Report is cohort-shaped and Umami: Run Attribution Report credits conversions to touches. Four of them share a property that is easy to get wrong: their window must be requested WHOLE. A visitor can enter a funnel in January and convert in February, and that path is invisible to two separate monthly runs, so running the halves and adding them does not reconstruct the range. Attribution is worse, because a first-touch credit that crosses the cut belongs to nobody afterwards, and retention cannot survive the split at all. Request the range you actually want to report on.
Sessions, events and property discovery
Umami: List Sessions returns visits for a window, Umami: Get Session fetches one, and Umami: Get Session Activity plays back what that visitor did. Umami: Get Session Stats aggregates the set, remembering that its numbers nest one level down. On the event side, Umami: List Events returns the raw rows, Umami: Get Event Stats aggregates them, and Umami: Get Events Series buckets them over time. The discovery pairs are the quietly useful part: Umami: List Event Properties and Umami: List Event Property Values tell you which custom properties an event actually carries and what values have been recorded, and Umami: List Session Properties and Umami: List Session Property Values do the same for sessions. An agent that reads these first stops guessing at property names. Both families are windowed, so they need a range like everything else here.
Websites, teams, links, and the four destructive nodes
Umami: Create Website and Umami: Update Website manage sites, which is the part an agency onboarding a client wants automated. Umami: List Teams, Umami: Get Team and Umami: List Team Websites cover the team surface, and they matter more than they look, because team-owned sites are hidden from the default website list. Umami: Create Link and Umami: Delete Link manage tracked short links, and Umami: Create Report and Umami: Delete Report manage saved reports; Umami: Get Report and Umami: List Reports read them, though note Umami's report list is scoped to a website rather than being account-wide. Four nodes are destructive. Umami: Delete Website takes the website AND every pageview, session and event ever collected for it, with no separate retention step and no trash. Umami: Reset Website Data takes the data and keeps the website, which is the same loss under a gentler name. Umami: Delete Report and Umami: Delete Link are far smaller but still have no undo. Gate all four behind a condition or an approval task rather than a bare trigger.
Troubleshooting
Test Connection fails on a Cloud credential
Test Connection fails on a self-hosted credential
The website picker is empty, or shorter than my dashboard
A window is rejected or returns the wrong period
A template reading numbers from a stats node resolves to nothing
A breakdown does not add up to the site total
A funnel or attribution report disagrees with the same range run as two halves
Data disappeared after a workflow ran
An event property node returns nothing for a property I know exists
Related
The Umami MCP
What connecting Umami unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
Umami 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.