Menu

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.

Decide which Umami you are connecting: Umami Cloud or Self-hosted.
Umami Cloud: sign in, open your profile, then Settings, then API keys, then click Create key and copy the value.
Copy the key when it is shown. Umami Cloud does not use an x-umami-api-key header despite that claim appearing in many third-party write-ups; the key is sent as Authorization with Bearer, which is what the vendor's own curl example shows.
Self-hosted: note your install's root URL, for example https://analytics.example.com, along with the username and password you sign in to the dashboard with. No key is created for this path.
On self-hosted, your password is exchanged for a token at Umami's login endpoint and is never sent to any other endpoint. The token is cached briefly and refreshed automatically, because Umami documents no token lifetime. One practical consequence: a password changed in Umami stops working here within about half an hour rather than whenever a process happens to restart.

Connect Umami to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Umami from the list.
Click Create new credential and set Deployment to Umami Cloud or Self-hosted.
Umami Cloud: paste the key into API Key (Cloud only). Leave the host, username and password blank. If you use a regional Cloud base, set Cloud Region to us or eu; leave it blank for the global base.
Self-hosted: fill Umami URL (self-hosted only) with your root URL, then Username (self-hosted only) and Password (self-hosted only). Leave the API key blank. A bare hostname works, and a dashboard URL copied from the browser is trimmed back to the root.
Credentials are stored encrypted in Google Secret Manager and never appear in workflow logs.
Click Test Connection. Mattering normalizes your base URL, performs the login exchange if you are self-hosted, reads the current account and reports your username back. That proves the whole chain on either deployment, including the login step that every self-hosted node depends on.
Click Connect. All 43 Umami nodes appear in your canvas palette.

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
Check three things in order. First, the key itself: copy it again and watch for leading or trailing whitespace, and confirm it still exists under Settings then API keys in Umami Cloud. Second, the deployment field: a credential set to Self-hosted does not send the API key at all, by design, so a key sitting in a self-hosted credential will never be used. Third, the header claim you may have read elsewhere: Umami Cloud is not an x-umami-api-key API. It uses Authorization with Bearer, which is what this connector sends, so nothing needs configuring there. If the key page has no Create key button, check the plan: API access starts at Pro on Umami Cloud, and the connector cannot work around a key that cannot be minted. Self-hosting has no such gate.
Test Connection fails on a self-hosted credential
On self-hosted, the test performs a login before it reads anything, so a failure here is usually the login rather than the read. Confirm the username and password sign you in to the dashboard itself. Confirm the URL is your install's ROOT, not a dashboard path, though a pasted dashboard URL is trimmed back for you. Confirm it is https: plain http is refused deliberately, because a password on the wire in the clear is interceptable, and no upgrade is attempted silently. Finally, confirm the host is reachable from outside your own network, since an install behind a VPN or a private network is not reachable from a hosted workflow runner.
The website picker is empty, or shorter than my dashboard
Team-owned websites are the usual answer. Umami's website list hides them unless you ask for them, and the default is off, so an agency whose client sites live under a team gets an empty-looking picker. Turn on the include-teams option in Umami: List Websites, or reach them directly with Umami: List Teams followed by Umami: List Team Websites. If the list is still short, check that the credential belongs to the account that actually owns the sites: on Cloud, a key minted on a different account is perfectly valid and simply sees different websites.
A window is rejected or returns the wrong period
You have almost certainly crossed the two date encodings. The statistics, events and sessions nodes take Unix time in MILLISECONDS. The seven report-run nodes take ISO 8601 date-times. A date string templated into a millisecond field is rejected or coerced to something meaningless, and a millisecond number sent to a report node is rejected the same way. Read the field's own description, which says which one it wants, and do not copy a window value between the two families. If a scheduled refresh is re-fetching the same fixed dates forever, the fix is the same idea from the other direction: substitute a relative window into the start and end fields rather than hard-coding them.
A template reading numbers from a stats node resolves to nothing
Two nodes look alike and are shaped differently. Umami: Get Website Stats returns its measures FLAT. Umami: Get Session Stats nests every number one level down under a value key, so a path that worked on the first resolves to nothing on the second. Check the node's sample output rather than assuming. A related shape to know: Umami: Get Pageviews Series returns two parallel series, pageviews and sessions, and the rows of both use the same column name with nothing in the row identifying which series it came from, so read them from their own named regions rather than merging the rows.
A breakdown does not add up to the site total
Expected, and worth designing around rather than debugging. Umami: Get Metrics Breakdown and Umami: Get Expanded Metrics Breakdown are ranked and truncated at the limit you set (Umami's own default is 500), so they answer top N rather than everything. Summing a truncated ranking will not reach the total, and two months of top N does not recombine into the pair's top N, because the limit changes which rows exist rather than merely clipping the response. Use Umami: Get Website Stats when you need a real range total.
A funnel or attribution report disagrees with the same range run as two halves
Both answers can be right; the two-half version is answering a different question. A visitor can enter a funnel in one month and convert in the next, and that path is invisible to two separate monthly runs, so Umami: Run Funnel Report and Umami: Run Journey Report cannot be assembled from pieces. Umami: Run Attribution Report is worse: a first-touch credit that crosses the cut belongs to nobody once the window is split. Umami: Run Retention Report is cohort-shaped and does not survive splitting at all. Request the window you actually want to report on as one range.
Data disappeared after a workflow ran
Check which node ran. Umami: Delete Website removes the website AND every pageview, session and event ever collected for it, with no separate retention step and no trash, and Umami: Reset Website Data does the same to the data while keeping the website. Neither has an undo in Umami's API, and neither is recoverable from Mattering. Both are flagged destructive precisely so they can be gated: put them behind a condition or an approval task rather than a bare trigger, keep agents on the read nodes, and point anything experimental at a throwaway website. On a self-hosted install your own database backups are the only recovery path, so it is worth confirming they exist before an automation is allowed near these nodes.
An event property node returns nothing for a property I know exists
Two likely causes, both about scope rather than about the connector. First, these readers are WINDOWED: Umami: List Event Properties and Umami: List Event Property Values only see properties recorded inside the range you gave, so a property last sent months ago will not appear in a seven-day window. Widen it. Second, the property NAME is a string from your own tracking payloads rather than an id, so it has to match exactly, including case. Run Umami: List Event Properties first over a generous window and take the name from its output rather than typing it, which is what those two nodes exist for.

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.

Start Free Explore our Products