Menu
Mattering Automations connector

An Umami MCP that works on Umami Cloud and on your own install

Connect one Umami credential and 43 nodes land on the 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 including funnel, journey, retention and attribution, plus website management, teams and tracked short links. An AI agent can read yesterday's numbers, run a funnel, and write the result somewhere a person will see it.

43 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Umami MCP connector does

The Umami connector for Mattering Automations is 43 nodes on Umami's documented API, 35 that read and 8 that act. The reporting half is the whole dashboard surface: Umami: Get Website Stats for the summary numbers, Umami: Get Pageviews Series and Umami: Get Events Series for time series, Umami: Get Metrics Breakdown and Umami: Get Expanded Metrics Breakdown for one-dimension rankings, Umami: Get Realtime Activity and Umami: Get Active Visitors for what is happening now, and the sessions family for who was there and what they did. On top of that sit seven runnable reports: breakdown, goal, funnel, journey, retention, attribution and UTM, each one a node that takes its query in configuration and returns rows.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. Ask an agent how the signup funnel did last month and it runs Umami: Run Funnel Report; ask which referrers brought the traffic and it runs Umami: Get Metrics Breakdown. Because the same nodes are steps on an automation canvas, that answer can become a scheduled report, a row in a Mattering database, or a task, rather than a chat message that scrolls away.

Umami ships in two deployments and this connector models both, deliberately. 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, because Umami documents no token lifetime. Both send an Authorization Bearer header, and one widely repeated third-party claim is worth correcting here: Umami Cloud does not use an x-umami-api-key header, whatever you may have read. The vendor's own curl example is Authorization with Bearer. Every documented path below the base is identical across the two deployments, which is what makes one node set serve both: you pick the deployment explicitly on the credential and fill in only that half.

Four of the 43 nodes are destructive and each names exactly what it takes. Umami: Delete Website removes 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. Umami: Delete Report and Umami: Delete Link remove a saved report and a tracked short link. Everything else either reads or creates.

One connection, three surfaces

  • Visual automations. Drag Umami nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Umami node, ready to drop on the canvas

43 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 35

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Connecting Umami takes one credential

The credential starts with an explicit deployment choice rather than an inference, because a wrong guess here produces a confusing provider error instead of a clear one. Choose Umami Cloud and you fill in one field, an API key created in Umami Cloud under your profile, then Settings, then API keys, then Create key. Note that API access is a paid Cloud feature: Umami's pricing page lists it from the Pro plan up, and the free Hobby plan does not include it, so a Cloud workflow needs Pro or above. Self-hosting has no such gate, because Umami is MIT licensed and free to run yourself. Optionally choose a region, which Umami documents as an extra path segment on the Cloud base. Choose Self-hosted and you fill in three: your install's root URL, your dashboard username, and your dashboard password. The 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 and caching close to an unknown expiry turns a long-running worker into an intermittent failure. The host field takes a bare hostname, a full URL, a trailing slash or a dashboard URL copied out of the browser and normalizes them all to the same API root, while plain http is refused rather than upgraded, because a username and password on the wire in the clear are interceptable. On limits, the two deployments differ. Umami Cloud documents 50 API calls every 15 seconds per API key, and it is per key rather than per account, so several workflows sharing one key share one budget. Self-hosted publishes no rate limit, which is a statement about the documentation rather than a promise, and in practice the ceiling is your own database. And on the commercial side, Umami is free to self-host under an MIT licence, while Umami Cloud is a paid product whose free Hobby plan does not include API access, so a Cloud workflow needs Pro or above and free testing means self-hosting. One node family is gated by deployment rather than by plan, and it is gated by the vendor: Umami states that its users and admin endpoints are not available for Umami Cloud, which is why this connector does not ship them at all.

1

Decide which Umami you are connecting. Umami Cloud: open your profile, then Settings, then API keys, and click Create key, then copy the value. Self-hosted: note your install's root URL and the username and password you sign in to the dashboard with.

2

In Mattering Automations, open Connectors, click Add Connector, and choose Umami.

3

Create a credential. Set Deployment to Umami Cloud or Self-hosted, then fill in only that half: the API key for Cloud, or the URL, username and password for self-hosted.

4

Click Test Connection. Mattering resolves your base URL, performs the login exchange if you are self-hosted, and reads the current account, reporting your username back. That proves the credential end to end on either deployment.

5

All 43 Umami nodes appear in the canvas palette. Run Umami: List Websites first: the website id it returns is the value nearly every other node needs, and the pickers on those nodes are filled straight from it.

Common uses for the Umami MCP

Yesterday's numbers, delivered rather than visited

Umami: Get Website Stats returns the summary set for a window: pageviews, visitors, visits, bounces and total time, with an optional comparison against the preceding period. Umami: Get Pageviews Series returns the same traffic as a time series at whichever bucket width you ask for, from minute to year. Put either behind a schedule and the dashboard stops being somewhere anyone has to remember to open: the numbers land in a Mattering database, an agent drafts the sentence that explains them, and a task opens only when a threshold moves. Two things to know while building. The window on these nodes is expressed in Unix milliseconds rather than dates, and the comparison object a node returns describes a DIFFERENT period from the one you asked for, so keep the two apart rather than merging them.

Rankings: pages, referrers, countries, browsers

Umami: Get Metrics Breakdown answers one dimension at a time for a window, and Umami: Get Expanded Metrics Breakdown returns the richer row shape. This is the surface behind most questions an agent gets asked: which pages, which referrers, which countries, which browsers, which UTM source. Filters are the other half of it. Umami documents a long list of filterable fields, path, referrer, title, query, browser, os, device, country, region, city, language, hostname, tag, event and the five UTM parameters among them, and the nodes take them as one filter object rather than twenty separate fields. One property to design around, which the node states: these breakdowns are RANKED and truncated at the limit you set, so they answer top N rather than everything, and January's top N plus February's top N is not the top N of the pair.

A live count that a workflow can act on

Umami: Get Active Visitors is the cheapest read in the connector, a single current number, and Umami: Get Realtime Activity returns the trailing activity behind it as a fixed recent window with nothing to configure. Together they are what you point a poll at when you want a workflow, not a chart: post the count to a channel when a launch goes live, open a task when a campaign page goes quiet, or let an agent answer how many people are on the site right now without opening a browser. Pick the polling interval conservatively rather than aggressively. On Umami Cloud there is a published number to design against: 50 API calls every 15 seconds per key, and it is per key rather than per account, so several workflows sharing one key share one budget. Self-hosted publishes none, where the practical limit is your own database.

Seven reports, run as steps rather than opened as screens

Umami: Run Breakdown Report, Umami: Run Goal Report, Umami: Run Funnel Report, Umami: Run Journey Report, Umami: Run Retention Report, Umami: Run Attribution Report and Umami: Run UTM Report each take their query in configuration and return rows, so a funnel is a workflow step and its output can go into a condition, a database, or a summary. These are the nodes that make an agent genuinely useful on Umami, because the question a person actually asks is usually a funnel or an attribution question rather than a pageview count. Two build notes. These nodes take ISO 8601 date-times rather than the epoch milliseconds the statistics nodes take, so do not copy a value between the two families. And a funnel, journey, retention or attribution run has to be requested as ONE window: a visitor who enters in January and converts in February is invisible to two monthly runs, so splitting the range does not reassemble into the whole.

Discover what you are actually tracking

Umami: List Events returns the raw event rows for a window and Umami: Get Event Stats aggregates them. Under that, Umami: List Event Properties and Umami: List Event Property Values are the discovery pair: they tell you which custom properties an event actually carries and what values have been seen, which is how an agent works out what to query before it queries it rather than guessing at names. The session side mirrors it with Umami: List Session Properties and Umami: List Session Property Values, plus Umami: List Sessions, Umami: Get Session and Umami: Get Session Activity for a single visit end to end. Saved reports are addressable too, through Umami: List Reports and Umami: Get Report.

Website admin, teams and tracked links

The eight action nodes cover the parts of Umami that are not reporting. Umami: Create Website, Umami: Update Website, Umami: Reset Website Data and Umami: Delete Website manage the sites themselves, which is what an agency onboarding a client actually needs automated. Umami: List Teams, Umami: Get Team and Umami: List Team Websites cover the team surface, which matters more than it looks: team-owned websites are HIDDEN from the ordinary website list unless you ask for them, so an agency whose client sites live under teams needs these nodes to see everything. Umami: Create Link and Umami: Delete Link manage tracked short links, and Umami: Create Report and Umami: Delete Report manage saved reports. Deleting a website is the one to gate: it takes every pageview, session and event with it.

Example: A weekly client report that writes itself, across every site an agency runs

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a weekly schedule fires on Monday morning.

2

Umami: List Websites returns the sites to report on, with team-owned sites included, because they are hidden from the default list and an agency's client sites usually live under teams.

3

For each site, Umami: Get Website Stats runs over the last seven days with the comparison option on, so the run has both this week's numbers and the preceding period beside them. Both window bounds are Unix milliseconds on this family of nodes.

4

Umami: Get Metrics Breakdown runs twice for the same window, once on pages and once on referrers, giving the two rankings that explain most of the movement. Both are top N rather than everything, which is fine for a digest and worth remembering before anyone sums them.

5

Umami: Run Funnel Report runs the signup funnel for the same week as a SINGLE window, because a funnel cannot be assembled from two half-windows.

6

Everything lands in a Mattering database keyed by site and week, so the history accumulates without anyone maintaining a spreadsheet.

7

Matter drafts one short paragraph per site from the numbers, and a task opens for the account owner with the draft attached. On a week where nothing moved outside its usual range, the condition skips the task and the row is simply stored.

Umami MCP questions, answered

What Umami operations are supported?

43 nodes: 35 read and 8 act. Reading covers the account, websites and teams, the full statistics surface (summary stats, active visitors, date range, pageview and event series, ranked one-dimension breakdowns in both the compact and expanded shapes), realtime activity, events with their stats and property discovery, sessions with their stats, activity and property discovery, saved reports, tracked links, and seven runnable reports: breakdown, goal, funnel, journey, retention, attribution and UTM. Acting covers create, update, reset and delete for websites, create and delete for saved reports, and create and delete for tracked links. Deliberately not shipped: Umami's users and admin endpoints, which the vendor states are not available for Umami Cloud and which require an admin account on a self-hosted install; the pixels surface; revenue and web-vitals performance reporting, both of which depend on opt-in capture; and the tracking endpoint itself, because hits sent from an automation runner would all carry one address and one user agent.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively. The same nodes also run as steps on an automation canvas, on a schedule, with nobody present, which is the part a chat-only setup cannot do.

Does Umami publish its own MCP server?

Not as of August 2026. No first-party Umami MCP server appears in Umami's documentation or its repository, so there is no vendor tool to weigh this connector against, and that is part of why this page exists. If one ships later, the honest comparison is the same one that applies elsewhere: a connector like this one runs the nodes on a schedule or off a trigger with nobody present, chains them with every other connector in one workflow, holds the credential once in a shared workspace rather than in each person's own client config, and flags the four destructive nodes so you can gate them.

Does it work with a self-hosted Umami, or only Umami Cloud?

Both, and self-hosted was modelled deliberately rather than added on. Umami is open source and a large share of installs are somebody's own container behind their own domain, so a Cloud-only connector would have shipped the minority deployment while looking complete. The credential carries an explicit deployment choice. Umami Cloud uses an API key from Settings then API keys. Self-hosted uses your dashboard username and password, which the connector exchanges for a token at Umami's login endpoint and refreshes automatically, since Umami documents no token lifetime. Every documented path below the base is identical across the two, so the node set, the pickers and the outputs are the same either way. Only the base URL and where the bearer token comes from differ.

Why is my website list empty or missing sites I can see in the dashboard?

Almost always the team setting. Umami's website list hides team-owned websites unless you ask for them, and the default is off, so an agency whose client sites live under a team sees an empty-looking picker and concludes the connector is broken. Turn the include-teams option on in Umami: List Websites, or reach them directly through Umami: List Team Websites after Umami: List Teams. If the list is empty for a Cloud credential regardless, check that the API key was created on the account that owns those sites, and check that the account is on a Cloud plan with API access, which starts at Pro.

What are Umami's rate limits?

Umami Cloud documents 50 API calls every 15 seconds per API key. That is per key rather than per account, so several workflows sharing one key share one budget. Self-hosted is different: Umami documents no rate limit for it, which is a statement about the documentation rather than a promise, and in practice the limit is your own database. Either way, reach for Umami: Get Active Visitors rather than a heavier read when all you want is a live count.

Why do some nodes want epoch milliseconds and others want dates?

Because Umami's API uses both, and this is the single most common way a working configuration gets broken by copy and paste. The statistics, events and sessions nodes take their window as Unix timestamps in MILLISECONDS. The seven report-run nodes take theirs as ISO 8601 date-times. One connector, two encodings, so a value moved from one family to the other will be rejected or, worse, coerced into something wrong. Every affected field says which it wants in its description, and the config schema types them differently so the panel helps rather than hinders.

Can an AI agent delete my analytics data?

Four of the 43 nodes can act destructively, and each is flagged so you can gate it. Umami: Delete Website removes the website and every pageview, session and event ever collected for it. There is no separate retention step and no trash, so it is not recoverable from Umami. Umami: Reset Website Data takes the data and keeps the website, which is the same loss with a friendlier name. Umami: Delete Report and Umami: Delete Link remove a saved report and a tracked short link, both far smaller in blast radius. The pattern that keeps this calm is the ordinary one: hand agents the 35 read nodes plus the create nodes, put the deletes behind a condition or an approval task rather than a bare trigger, and keep experiments on a throwaway website.

Are the numbers safe to add up across days?

Some of them, and the connector is explicit about which, because this is where dashboards go quietly wrong. Pageviews, visits, bounces and total time are counts, so they add up across partitions. Visitors do not: it is a count of distinct people, and thirty daily unique counts is not the monthly unique count on any analytics platform. Bounce rate and average visit duration are not columns Umami returns at all; its dashboard derives them at read time, so anything claiming to aggregate them directly is inventing data. Both are recoverable after the fact, because their numerator and denominator are both additive. The ranked breakdowns are a separate trap: they return the top rows only, so summing two months of top N does not give you the top N of the two months.

43 nodes waiting on the canvas

Put Umami to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Umami is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products