# Node.js Error Monitoring & Performance Monitoring

> Distributed tracing, profiling, and logs across Express, Fastify, NestJS, Koa, and Hapi — in both ESM and CommonJS. Free to start.

**URL:** https://sentry.io/for/node/

---

**Documentation:** [https://docs.sentry.io/platforms/javascript/guides/node/](https://docs.sentry.io/platforms/javascript/guides/node/)

## Install

### Node

Grab the [Sentry Node SDK](https://github.com/getsentry/sentry-javascript/):

```bash
npm install @sentry/node
```

Configure your SDK:

```javascript
const Sentry = require('@sentry/node');
Sentry.init({ dsn: 'https://<key>@sentry.io/<project>' });
```

See the [Node docs](https://docs.sentry.io/platforms/javascript/guides/node/) for full setup options.

### Express

Add `@sentry/node` as a dependency:

```bash
npm install --save @sentry/node
```

Sentry should be initialized as early in your app as possible:

```javascript
import express from "express";
import * as Sentry from "@sentry/node";

const app = express();

Sentry.init({ dsn: "https://<key>@sentry.io/<project>" });

// The request handler must be the first middleware on the app
app.use(Sentry.Handlers.requestHandler());

// All controllers should live here
app.get("/", function rootHandler(req, res) {
  res.end("Hello world!");
});

// The error handler must be before any other error middleware and after all controllers
app.use(Sentry.Handlers.errorHandler());

app.listen(3000);
```

See the [Express docs](https://docs.sentry.io/platforms/javascript/guides/express/) for full setup options.

### Koa

Add `@sentry/node` as a dependency:

```bash
npm install --save @sentry/node
```

See the [Koa docs](https://docs.sentry.io/platforms/javascript/guides/koa/) for full setup options.

### Fastify

Add `@sentry/node` as a dependency:

```bash
npm install --save @sentry/node
```

See the [Fastify docs](https://docs.sentry.io/platforms/javascript/guides/fastify/) for full setup options.

### Hapi

Add `@sentry/node` as a dependency:

```bash
npm install --save @sentry/node
```

See the [Hapi docs](https://docs.sentry.io/platforms/javascript/guides/hapi/) for full setup options.

### NestJS

Add `@sentry/nestjs` as a dependency:

```bash
npm install --save @sentry/nestjs
```

See the [NestJS docs](https://docs.sentry.io/platforms/javascript/guides/nestjs/) for full setup options.

## Features

### Powered by OpenTelemetry

Sentry works with OpenTelemetry to provide a simple configuration process, and rich [distributed tracing](/product/tracing/) context across all the libraries and frameworks used in your application. Regardless of your chosen tech stack.

### Node Performance Monitoring

Quickly identify Node [performance](/product/tracing/) issues and view full end-to-end distributed trace to see the exact, poor-performing API call and surface any related errors.

### Complete Stack Traces, in ESM and CommonJS

See the Node source code at each frame instead of settings for just line and column numbers. Get proper asynchronous context tracking — like thread-local store — in a way that fits Node's concurrency model.

### Fill In The Blanks

See what the app was doing when the Node error occurred: HTTP requests, database queries, console loft statements, etc.

### Profiling, Down to the Function

Profiling lets you see what parts of your code are consuming the most resources, like CPU or memory, in your application— so you can optimize them before end user experience is impacted. Test your application performance in any environment, including in production, without writing manual tests or extensive troubleshooting.

### Your Logs, Next to the Trace

Centralize logs from your Node services in Sentry and query them beside the distributed [trace](/product/tracing/) that produced them. The log lines around a failed request are already attached to it, so debugging a production incident does not mean stitching together two tools.

Learn more about [Logs in Sentry](/product/logs/).

## FAQ

**What is the difference between Sentry and traditional logging?**

Traditional logging provides you with a trail of events. Some of those events are errors, but many times they're simply informational. Sentry is fundamentally different because we focus on exceptions, or in other words, we capture application crashes. We discuss in more detail [here](/vs/logging/) and on our [blog](https://blog.sentry.io/lets-get-ready-to-monitor/).

**What  languages does Sentry support?**

Sentry supports every major  language, framework, and library. You can browse each of them [here](/platforms/).

**How much does Sentry cost?**

You can get started for free. Pricing depends on the number of monthly events, transactions, and attachments that you send Sentry. For more details, visit our [pricing page](/pricing/).

**How does Sentry impact the performance of my app?**

Sentry doesn't impact a web site's performance.

If you look at the configuration options for when you initialize Sentry in your code, you'll see there's nothing regarding minimizing its impact on your app's performance. This is because our team of SDK engineers already developed Sentry with this in mind.

Sentry is a listener/handler for errors that asynchronously sends out the error/event to Sentry.io. This is non-blocking. The error/event only goes out if this is an error.

Global handlers have almost no impact as well, as they are native APIs provided by the browsers.

**Does Sentry work with ESM and CommonJS in Node.js?**

Yes. The Sentry Node.js SDK supports both CommonJS and ECMAScript modules, and instruments worker threads as well as your main process. On Node 18.19.0+ and 19.9.0+ it can also use `TracingChannel` diagnostics for more accurate instrumentation.

Sentry ships integrations for [Express](/for/express/), [Fastify](/for/fastify/), [NestJS](/for/nestjs/), [Koa](/for/koa/), [Hapi](/for/hapi/), Connect and dozens of other JavaScript frameworks, plus OpenTelemetry support if you already have an OTel pipeline.

**Can Sentry monitor MCP servers and AI agents?**

Yes. The Node.js SDK includes MCP (Model Context Protocol) server monitoring and agent tracing, so tool calls and agent steps show up as spans on the same traces as the rest of your backend.

That means a failing tool call, a slow model response, and the HTTP request that triggered them all sit on one trace. Learn more about [AI Agent Monitoring](/product/tracing/ai-agent/).

**Can I send logs to Sentry?**

Yes. Sentry Logs lets you send, view, and query structured logs from your application alongside your errors and traces. Because logs sit next to the error and the trace that produced them, you get the granular context — retries, API failures, internal state — that spans and stack traces alone can miss, without switching tools.

Learn more about [Logs in Sentry](/product/logs/).

**What is Seer, Sentry's AI debugging agent?**

Seer is Sentry's AI debugging agent. It reads the full context Sentry already has — the error, its stack trace, the surrounding trace, logs, and profiles — to find the root cause of an issue and propose a fix. Seer can open a pull request with that fix, hand the work to an external coding agent, or review your PRs before they ship.

Learn more about [Seer](/product/seer/) and [Autofix](/product/seer/autofix/).

---

*Source: [sentry.io/for/node/](https://sentry.io/for/node/)*