Skip to content
UmamiEngine logoUmamiEngine
Features Pricing Comparison FAQ
For Shopify Sellers For Bloggers For WordPress
Blog Tools About Log in Start free
Log inStart free

Umami 3.5.0: Browser Error Tracking – Monitor JavaScript Errors Alongside Your Analytics

Updated: November 2026

Privacy-first analytics without the DevOps. Managed Umami from $5/mo — 14 days free, no card required.

Start free trial

Website analytics can tell you how many visitors you have, which pages they visit, and how they interact with your website. But there is another important question that traditional analytics often cannot answer: Are your visitors experiencing errors that prevent them from using your website properly?

With the release of Umami 3.5.0, this becomes easier to investigate. Umami introduces browser error tracking, a feature that captures JavaScript exceptions directly from visitors' browsers, groups related errors into issues, and connects them to the sessions in which they occurred.

This means you can investigate technical problems alongside your existing website analytics instead of relying entirely on separate monitoring tools.

In this guide, we'll explain what Umami's new error tracking feature does, how to enable it, how to report errors manually, and how to investigate and manage issues.

What Is Browser Error Tracking?

Browser error tracking is the process of collecting JavaScript errors that occur while visitors interact with your website.

Modern websites rely heavily on JavaScript. It powers interactive elements, navigation, forms, shopping carts, authentication, and many other features.

When something goes wrong, JavaScript can generate an exception that interrupts the expected behavior of your application.

For example:

  • A checkout button stops working because of a JavaScript exception.
  • A registration form fails to submit because of an unexpected response.
  • A navigation component crashes after a user interacts with it.
  • A third-party integration causes an unexpected JavaScript error.
  • A new deployment introduces a bug that affects a particular browser.

These problems might not be obvious during development or testing. They can also affect only certain browsers, devices, or user interactions.

Without error tracking, you might discover the problem only after receiving customer complaints or noticing a decline in conversions.

Umami 3.5.0 addresses this by allowing you to capture browser-side JavaScript errors and investigate them directly from your analytics dashboard.

What's New in Umami 3.5.0?

The new error tracking functionality is available starting with Umami 3.5.0.

It introduces several capabilities:

Automatic error collection: Umami automatically captures uncaught JavaScript exceptions and unhandled promise rejections.

Issue grouping: Related errors are grouped into issues, making it easier to identify recurring problems rather than examining individual error reports.

Release and environment tracking: Associate errors with application versions and deployment environments to identify problems introduced by specific releases.

Stack traces: Investigate the technical origin of an error using its stack trace.

Session integration: Open the visitor's session to understand what happened before the error occurred. If session replay was recorded, you can also watch the replay.

Issue management: Mark issues as resolved or ignored, and reopen them when necessary.

The feature is particularly useful because it brings error monitoring closer to the behavioral analytics you already use in Umami.

How to Enable Error Tracking in Umami

Enabling browser error tracking is straightforward. You don't need to install a separate JavaScript monitoring library or configure an additional collection endpoint.

You only need to update your existing Umami tracking script.

Step 1: Update Your Umami Installation

First, make sure you're running Umami 3.5.0 or later.

If you're self-hosting Umami, upgrade your installation to a compatible version and apply the required database migrations.

If you're using a managed Umami hosting service, check that your provider has upgraded its infrastructure to support version 3.5.0.

Step 2: Enable Error Tracking

Open your website's tracking code and add the following attribute:

data-errors="true"

Your tracking script should look similar to this:

<script
  defer
  src="https://your-umami-instance.com/script.js"
  data-website-id="your-website-id"
  data-errors="true"
></script>

Replace the script URL and website ID with the values from your Umami installation.

That's it. Umami will now automatically capture uncaught JavaScript exceptions and unhandled promise rejections from visitors' browsers.

You don't need to change your existing pageview or event tracking configuration.

Step 3: Add Release and Environment Information

For a more useful error monitoring setup, it's recommended to identify the application version and environment associated with each error.

You can do this using two additional attributes:

  • data-release: Identifies the application version or deployment.
  • data-environment: Identifies the environment where the application is running.

For example:

<script
  defer
  src="https://your-umami-instance.com/script.js"
  data-website-id="your-website-id"
  data-errors="true"
  data-release="1.2.0"
  data-environment="production"
></script>

The environment defaults to production if you don't specify it.

You could use different configurations for different environments:

Environment Release Environment
Local development 1.2.0 development
Staging 1.2.0-rc1 staging
Production 1.2.0 production

This information becomes particularly valuable when investigating errors after a deployment.

For example, if an error suddenly appears after releasing version 1.2.0, you can filter your reports by release and investigate whether the new deployment introduced the problem.

You can also configure these options through window.umamiConfig instead of HTML attributes.

How to Report Errors Manually

Automatic error tracking captures uncaught exceptions and unhandled promise rejections.

However, not every error is automatically reported.

Consider a situation where your application catches an exception using a try...catch block. Since your application handles the error, Umami won't automatically capture it.

This is where the umami.captureException() function becomes useful.

Basic Usage

Consider the following JavaScript example:

try {
  await submitOrder();
} catch (error) {
  umami.captureException(error);
}

Whenever submitOrder() throws an exception, the catch block handles it and sends the error to Umami.

This allows you to monitor errors that your application handles internally without necessarily allowing them to interrupt the user experience.

Adding Additional Context

You can also attach additional information to an error using the optional second argument.

try {
  await submitOrder();
} catch (error) {
  umami.captureException(error, {
    release: '1.2.0',
    environment: 'production',
    tags: {
      feature: 'checkout'
    }
  });
}

The additional options include:

Option Description
release Overrides the release configured in the tracking script.
environment Overrides the environment configured in the tracking script.
tags Adds contextual key-value pairs to the error occurrence.
fingerprint Defines custom grouping identifiers for related errors.

Tags are particularly useful when you want to identify the application component responsible for an error.

For example, you could use tags such as checkout, authentication, registration, or payment.

Umami supports up to 20 tags per error. Keys that resemble credentials or sensitive information, such as passwords, tokens, cookies, and email addresses, are dropped.

Custom Error Grouping

By default, Umami groups errors using their error type and the first 10 frames of their stack trace.

Sometimes, however, you might want to control how different errors are grouped.

The fingerprint option allows you to do that.

umami.captureException(error, {
  tags: {
    feature: 'checkout'
  },
  fingerprint: ['checkout-payment']
});

Errors reported with the same fingerprint can be grouped into the same issue.

This is useful when different underlying exceptions represent the same application-level problem.

How to View and Investigate Errors

Once error tracking is enabled and errors have been collected, you can investigate them directly from the Umami dashboard.

Step 1: Open the Errors Tab

Navigate to the website you want to monitor and select the Errors tab.

Umami displays a list of issues collected during the selected reporting period.

The overview includes:

  • Issue status.
  • Number of error occurrences.
  • Number of affected visits.
  • First time the error was observed.
  • Last time the error was observed.

There is also a chart showing daily error occurrences in UTC.

This gives you a quick overview of whether errors are increasing, decreasing, or appearing for the first time.

Step 2: Filter and Search Issues

As your website grows, you might collect many different errors.

Umami provides several filters to help narrow down the results.

You can filter issues by:

  • Status.
  • Release.
  • Environment.
  • Browser.
  • Page path.

You can also search for text within error messages.

For example, imagine that customers report problems with your checkout process after a new release.

You could filter the errors by the latest release, select the production environment, and narrow the results to your checkout page.

This makes it easier to isolate problems instead of searching through unrelated errors.

Step 3: Inspect an Error Occurrence

Click an issue to view its individual occurrences.

Selecting an occurrence gives you additional technical information, including:

  • Error message.
  • Stack trace.
  • Page where the error occurred.
  • Browser.
  • Operating system.
  • Device.
  • Application release.
  • Environment.
  • Associated tags.
  • Whether the error was automatically captured or manually reported.

The stack trace is especially useful for developers because it helps identify where an exception originated.

Step 4: Investigate the Visitor's Session

One of the most useful aspects of Umami's error tracking is its integration with session monitoring.

From an error occurrence, you can select View session to open the visitor's session.

If session replay was recorded when the error occurred, Umami also provides a View replay option.

This gives you additional context about what the visitor was doing before the problem happened.

For example, you might discover that:

  1. A visitor opened your pricing page.
  2. They selected a subscription plan.
  3. They proceeded to checkout.
  4. They clicked the payment button.
  5. A JavaScript exception occurred.

Instead of relying exclusively on the stack trace, you can examine the visitor's journey to better understand the circumstances that triggered the error.

This combination of error tracking and session replay can significantly reduce the time needed to reproduce and troubleshoot production problems. If replays are new to you, our Umami Session Replays guide explains how to enable and use them.

Managing Errors: Resolve, Ignore, and Reopen

Umami provides three statuses for managing reported issues.

Status Meaning
Unresolved The default status for newly discovered issues.
Resolved The issue has been fixed.
Ignored The issue does not require further action.

Once you've investigated an issue and deployed a fix, you can mark it as resolved.

If an issue is expected or doesn't require action, you can mark it as ignored.

If a previously resolved issue needs attention again, you can reopen it.

One important detail: changing an issue's status does not stop Umami from collecting new occurrences.

For example, if you resolve an issue but the same error happens again, Umami continues collecting it while retaining its resolved status.

You can therefore monitor whether a fix actually eliminated the problem rather than assuming that changing the status stopped the error.

Changing an issue's status requires permission to edit the associated website.

Privacy Considerations

Privacy is an important part of Umami's approach to analytics, and error tracking follows the same principles.

According to Umami's documentation, error tracking:

  • Records page URLs without query strings or hash values.
  • Redacts email addresses, JWTs, and values that resemble passwords, secrets, tokens, or API keys from error messages and stack traces.
  • Does not collect console logs.
  • Does not collect request bodies, cookies, or local variables.
  • Respects domain restrictions, Do Not Track settings, and exclusions for your own visits.

You can also use the data-before-send handler to inspect error payloads before transmission, remove sensitive information, or prevent particular errors from being sent.

For example:

function beforeSendHandler(type, payload) {
  if (type === 'error' && payload.url.startsWith('/admin')) {
    return false;
  }

  return payload;
}

In this example, errors associated with URLs beginning with /admin are excluded from collection.

An important consideration is that automatic redaction is best-effort. You should still avoid including sensitive information in error messages, stack traces, or custom tags.

Privacy-conscious error tracking does not automatically mean that every implementation satisfies every applicable privacy requirement. Review your own data collection practices and legal obligations.

Limitations of Umami Error Tracking

Although the new feature provides useful browser monitoring capabilities, it's important to understand what it does not capture.

Umami's browser error tracking does not automatically capture:

  • Errors occurring before the Umami tracking script loads.
  • Resource loading failures, such as broken images.
  • Errors inside web workers.
  • Server-side errors.

It also has a limitation when dealing with JavaScript files hosted on other domains.

Depending on the script's CORS configuration, errors originating from external scripts may appear only as a generic Script error. message.

To receive more useful error information, the external script needs to be served with appropriate CORS headers and loaded using the crossorigin attribute.

There are also collection limits:

Limit Value
Errors captured per page 20 per minute
Repeated identical error objects Ignored within 1 second
Maximum error message length 2,000 characters
Maximum stack trace length 16,000 characters
Maximum tags per error 20
Maximum error payload size 48,000 bytes
Errors accepted per website 120 requests per minute

Self-hosted installations can adjust the per-website collection limit using the ERRORS_PER_MINUTE environment variable.

These limits help control excessive error reporting and protect the collection infrastructure.

Why Browser Error Tracking Matters for Website Owners

Traditional analytics and error monitoring solve different problems.

Analytics helps you understand what visitors do. Error tracking helps you understand when technical problems interfere with those activities.

Combining the two provides a more complete picture of website performance.

Consider an online store experiencing a decline in completed purchases.

Traditional analytics might show that visitors are still arriving at the checkout page but fewer are completing their purchases.

Without error tracking, you might investigate pricing, marketing campaigns, or changes in customer behavior.

With Umami's new functionality, you can also investigate whether a JavaScript error is preventing visitors from completing the checkout process.

The same applies to registration forms, subscription flows, contact forms, and other important interactions.

For developers, this means fewer blind spots when monitoring production applications.

For website owners, it means better visibility into technical problems that could affect customer experience and conversions.

Final Thoughts

Umami 3.5.0 introduces a valuable addition to its analytics platform by bringing browser error tracking directly into the dashboard.

The ability to automatically capture JavaScript exceptions, group related issues, associate errors with releases, and investigate affected sessions makes it easier to understand what is happening on your website.

It is not a replacement for comprehensive application performance monitoring or server-side error monitoring. However, for browser-side JavaScript errors, it provides a convenient way to connect technical problems with actual visitor activity.

If you're already using Umami, enabling error tracking requires only a small change to your tracking script.

For developers and website owners who want better visibility into their websites without introducing another monitoring platform, this is a welcome improvement.

With Umami, you can now understand not only how visitors use your website, but also some of the technical problems they encounter along the way.

For a complete overview of everything else in this release, read our Umami v3.5 release summary.


Get Started with Managed Umami

Ready to try Umami without the DevOps hassle? UmamiEngine provides fully managed Umami analytics that runs the latest Umami version, including error tracking and session replays. No servers, no databases, no maintenance, just privacy-first analytics in minutes. Get started today and take control of your analytics data.

Get fully managed Umami in minutes

Keep reading

  • Umami v3.5: Browser Error Tracking and Security Updates
  • Umami Session Replays: See How Visitors Actually Use Your Website
  • Umami Analytics Dashboard: Complete Feature Walkthrough
UmamiEngine logoUmamiEngine

Hosted by Hetzner · Data in Germany/EU

Product

Home For Shopify Sellers For Bloggers For WordPress About

Resources

Blog Tools Self-Hosting Cost Calculator Contact

Legal

Terms of Use Privacy Policy Impressum

© 2026 UmamiEngine. All rights reserved.

$5/mo · 14 days free · No card Start free