---
title: Migrate from Sentry, or send OpenTelemetry exceptions
description: "Keep your Sentry SDKs and point the DSN at your own Venom Cloud, or export OpenTelemetry exception events with a collector: the DSN, the key, what is kept and what is dropped."
section: incidents
order: 25
audience: [builder, operator]
sources: [services/nodejs-cloud/lib/errors/compat, services/nodejs-cloud/app/incidents/otlp]
features: [cloud.incidents]
---

You do not have to change your error SDKs. A Sentry SDK (JavaScript, Python, Go and the rest) can report to Venom
Incidents by changing its DSN, and an OpenTelemetry collector can export exception events to it. Both go through the
same ingest as the [errors SDK](/docs/incidents/errors-sdk.md): the same grouping, hourly cap, scrubbing, releases and alerts. Nothing is
forwarded to a third party.

## Point a Sentry DSN at your cloud

```text
https://<client-side id>@<your cloud>/incidents/1
```

* The user part of the DSN is the **client-side id of a Flags environment** (`vfc_…`, on the environment's page). That
  environment is the one the errors land in. A server key (`vfs_…`) works too, sent as `Authorization: Bearer`, but a
  DSN carries only the public id, so use that.
* The last part (`1`) is only there because Sentry SDKs insist on a number. Venom ignores it: the project comes from the
  key.

```ts
Sentry.init({ dsn: "https://vfc_abc123@cloud.example.com/incidents/1", release: process.env.GIT_SHA });
```

The SDK posts to `/incidents/api/1/envelope/`. Old SDKs that use `/incidents/api/1/store/` work as well.

What is kept from an `event` item: the exception chain (the last exception is the one that was thrown, earlier causes
are noted), frames with `in_app` (innermost first), message, level, release, the user id (or username), tags, breadcrumbs,
request URL and contexts. The Sentry `environment` becomes the tag `sentry_environment`; the Flags environment comes from
the key.

* **Fingerprints.** An explicit `fingerprint` array is honoured. `"{{ default }}"` in it means "the default grouping, plus
  more", and Venom's default grouping is used.
* **Dropped, with a count.** Transactions, sessions, replays, attachments and client reports are accepted and thrown away so
  the SDK does not retry. The response lists them: `{"id": "…", "dropped": {"transaction": 2}}`.
* **Compressed bodies** (gzip, deflate) are accepted. A request is at most 200 KB after decompression.
* Source maps: upload them to the release as for the errors SDK; they are matched by release and file name.

## Export OpenTelemetry exceptions

Log records and span events that carry `exception.type`, `exception.message` and `exception.stacktrace` become Errors
events; the stack trace text is parsed into frames (V8, Python, Java and browser formats). `service.version` is the
release; `service.name` and `deployment.environment` become tags. Everything else in the export is ignored.

```yaml
exporters:
  otlphttp/venom:
    endpoint: https://cloud.example.com/incidents/otlp
    encoding: json
    headers:
      Authorization: "Bearer ${env:VENOM_FLAGS_SDK_KEY}"
service:
  pipelines:
    logs: { exporters: [otlphttp/venom] }
    traces: { exporters: [otlphttp/venom] }
```

The collector appends `/v1/logs` and `/v1/traces`. Only OTLP/JSON is accepted (`encoding: json`); protobuf gets a 415.
Up to 100 exceptions are stored per request.
