Sentry v11 and user data: what your error monitor collects
8 min read
Facts about Sentry are from its public documentation as of 17 November 2026. Sources are at the end.
The latest version of Sentry's JavaScript SDK sends more of your users' data by default than the version before it. Every copy of that data on another company's servers is one more place it can leak from, so it is worth knowing what your error monitor receives and whether it needs it. This article starts from the beginning. If you already know what monitoring tools do, skip to "What changed in Sentry v11".
What an application monitoring tool does
Once your app is live, you cannot see what happens inside it. A user clicks a button, something breaks, and unless they write to you, you never find out.
An application monitoring tool closes that gap. You add a small library to your code, called an SDK, and it reports to a dashboard whenever something goes wrong:
- errors, with the line of code that failed;
- pages and API requests that are slow;
- background jobs that failed or never ran.
It then emails or messages you, so you hear about a problem before your users tell you.
To explain an error, the tool needs context: which page, which request, what happened just before. That context is where your users' data comes in. A request can carry a name, an email address, a login cookie or a form the user just filled in. Whatever the SDK collects is copied to the monitoring company's servers.
Send outside tools only what they need
One of the oldest rules in security is to collect and share no more data than the job requires. It is usually called data minimisation, and the reasoning is simple. Data you never sent cannot leak, cannot be read by the wrong person and does not have to be found and deleted later.
The rule matters most with third-party tools. Once your users' data is on another company's servers, you no longer decide how it is stored, how long it is kept or what happens to it if that company is breached. You are still the one your users trusted with it.
An error monitor needs to know what broke and where. It rarely needs the form a user just submitted or their login cookie.
Security certifications are built on the same rule. SOC 2 is a report from an independent auditor confirming that a company follows its own security controls over a period of months. ISO 27001 is an international standard for managing information security, which an accredited body certifies you against. Both ask which outside companies receive your customers' data and what you send them, and so does the security questionnaire a larger customer sends before signing.
Where Sentry fits
Sentry is probably the best-known error monitoring tool, and for many teams the default choice. It may already be in your project, added by a starter template or an AI coding assistant. If your project is browser JavaScript or Node.js, open package.json and look for a line that starts with @sentry/. If its version number starts with 11, for example ^11.13.0, this article is about your app.
Python projects are heading the same way. Version 3.0 of Sentry's Python SDK, in beta as of November 2026, also collects request bodies and user information by default.
Sentry itself is SOC 2 Type II and ISO 27001 certified, and nothing here makes it unsafe. But those cover how Sentry protects the data it holds. What you send it is your decision, and your users' data stays your responsibility wherever it ends up.
What changed in Sentry v11
Install version 11 today, or upgrade from version 10 and change nothing else, and your server sends Sentry more of your users' data than it would have before. Request bodies (the data a form or API call submits), cookies and client IP addresses were opt-in in version 10. In version 11 they are opt-out.
Version 11 removes the sendDefaultPii switch and replaces it with a dataCollection option that has one setting per category. Sentry's migration guide is direct about the consequence: it is "a behavior change, not a rename."
| Category | v10, nothing configured | v11, nothing configured |
|---|---|---|
| Client IP address | Not sent | Sent |
| Cookies | Not sent | Sent |
| Request bodies | Size only | Incoming request bodies sent |
| HTTP headers | Sent, IP headers filtered | Sent |
| AI prompts and responses, with an AI integration | Not sent | Sent |
| Query data from some database integrations | Not sent | Sent |
| Query strings | Sent | Sent |
Two things did not change. The URL path of every request is always sent and cannot be turned off. And values whose key looks sensitive, such as password, token or auth, are replaced with [Filtered].
Why key-name filtering is not enough
Sentry's filters match field names, a short list of keywords and a basic credit card pattern. They cannot recognise personal data in general, and Sentry's own guide tells you to treat them as best effort. These all pass straight through:
Error: no invoice found for dana@example.com, because an error message is free text.GET /patients/48213/results, because the path is always sent.{"note": "card ending 4242, DOB 1988-02-11"}in a request body, becausenoteis not a sensitive name.
What sending too much costs you
An error monitor that only sees stack traces holds little that anyone could misuse. One that receives request bodies and cookies holds your users' data, and that gives you more to look after:
- More readers. Everyone with access to the project can read its events, so access to the tool deserves the same care as access to your database.
- More copies. Sentry's issue notifications include event data unless you turn on Enhanced Privacy in the organization's security settings, so the data also lands in inboxes.
- A bigger incident. If an account with access is taken over, or the vendor is breached, what leaks is whatever you sent.
- More to delete. When a user asks you to delete their data, the request now has to reach your monitoring data too.
- More to disclose. The tool belongs in your privacy notice and on the list of sub-processors your customers see, along with what it receives.
Most bugs can be fixed from the stack trace, the route and the status code. The rest is risk you carry without getting much back.
Put the old defaults back
If you want version 11 to behave like version 10, say so explicitly. This goes a step further than the old baseline and drops query strings too:
Sentry.init({
dsn: process.env.SENTRY_DSN,
dataCollection: {
userInfo: false,
cookies: false,
httpBodies: [],
urlQueryParams: false,
httpHeaders: {
request: { deny: ["forwarded", "-ip", "remote-", "via", "-user"] },
response: { deny: ["forwarded", "-ip", "remote-", "via", "-user"] },
},
genAI: { inputs: false, outputs: false },
databaseQueryData: false,
graphQL: { document: false, variables: false },
},
});
In version 3.0 of the Python SDK the same idea is the data_collection dictionary. Add "stack_frame_variables": False unless you are sure no local variable ever holds customer data.
Keep personal data out of error messages
No monitoring tool can reliably scrub free text, so fix this one in your code. It applies whichever product you use.
// Leaks: the address is stored by every tool that sees the error
throw new Error(`No invoice found for ${user.email}`);
// Better: a fixed message, with the detail in logs you control
logger.warn({ userId: user.id }, "invoice lookup failed");
throw new InvoiceNotFoundError("No invoice found for user");
A fixed message also groups more cleanly, because every occurrence looks the same.
What Vigilon collects by default
Vigilon's Node.js and Python SDKs are standard OpenTelemetry instrumentation with nothing added on top. Here is what that means for the same categories.
| Collected with no configuration | Sentry JS v11 | Vigilon server SDKs |
|---|---|---|
| Request and response bodies | Incoming request bodies | No |
| Cookies | Yes, sensitive names filtered | No |
| HTTP headers | Yes, sensitive names filtered | User agent only |
| AI prompts and responses | Yes, with an AI integration | No |
| Queue or job payloads | Queue message data | Job name and schedule only |
| Source code around each stack frame | 5 lines | No |
| Client IP address | Yes | Yes |
| URL path | Yes | Yes |
Vigilon's server SDKs also never attach local variables to stack frames.
In the browser, Sentry records clicks, key presses, network calls, navigation and console output as breadcrumbs by default. Vigilon's browser SDK records a narrower set:
- The query string, the fragment and any
user:password@are removed from page URLs, stack trace URLs and breadcrumb URLs. This happens in the browser and again when the event arrives. - Clicks are recorded by tag, ID and class name, never by the element's text.
- Network breadcrumbs hold the method, the URL without its query string, the status and the duration. No headers and no bodies.
- Console breadcrumbs cover warnings and errors only, unless you change that.
- It sets no cookies, has no session replay, and does not store the visitor's IP address.
- A user ID that looks like an email address is rejected.
Traces and browser events are deleted when your plan's retention window ends, which is 30 or 60 days.
A 15-minute audit of your error monitor
- Find the SDK versions you run in production. Check whether a dependency update moved you to Sentry JS v11 or Python 3.0.
- Trigger an error on a request with a body, a cookie and a query string, all filled with made-up values.
- Open the event and look for each of those values. Check the breadcrumbs and the trace too.
- Open the alert email or chat notification for the same error and repeat.
- Search recent errors for an
@sign. An address in a message means a code fix. - List who has access to the tool and compare it with who should.
- Write down what you found and the configuration you chose, so the next check has something to compare against.
Run it again after every major SDK upgrade. Version 11 is the reason why.
Fewer settings, fewer ways to get it wrong
The version 11 change is a reminder that every setting is a decision someone on your team has to make, and make again after each upgrade. Most teams are not monitoring or security specialists, and should not need to be. Vigilon was built from the start to make those decisions for you.
- Which traces to keep. You set no sample rate. Vigilon keeps the full trace for every request that errors, every request slower than one second and every job run, plus a sample of fast, successful requests.
- Metrics. There is nothing to define. Traffic, latency and error-rate charts count every request, before any sampling.
- Errors and alerts. Exceptions are grouped for you, and you get an email when a new error appears or a resolved one comes back.
- What is collected. There is no option that turns on request bodies, cookies or headers.
- Setup. On Node.js it is one start flag and an API key.
The trade-off is fewer knobs. If you want to tune every category yourself, Sentry gives you that control. If you would rather not make those choices at all, see Vigilon as a Sentry alternative.
Sources
All checked on 17 November 2026.