# Sentry-Alarme aufs Handy: Push-Benachrichtigungen für Fehler, ohne Code

> Sende Sentry-Issue- und Metrik-Alarme als Push-Benachrichtigung auf dein iPhone oder Android-Handy. Eine interne Sentry-Integration, ein Pocket-Alert-Webhook, funktionierende Templates für die echten Payloads, ein Button „Open in Sentry“ und eine ehrliche Einordnung der Level.

*19.10.2026*

<!-- source: https://pocketalert.app/de/blog/sentry-alerts-to-phone -->

Sentry erkennt die Exception in dem Moment, in dem sie auftritt. Dann schickt es dir eine E-Mail oder postet in einen Slack-Channel, der auch Deploy-Meldungen, Standup-Erinnerungen und ein paar hundert andere Dinge bekommt. Wenn der Fehler um 2 Uhr nachts passiert oder du gerade nicht am Laptop sitzt, erfährst du es, wenn ein Nutzer sich meldet.

Sentry-Alarme können das besser, nur hat Sentry keine eigene Push-App für Alarme. Was es hat, ist ein Webhook, der auslöst, sobald eine Alarmregel greift. Richte ihn auf Pocket Alert, und jeder Alarm wird zur Push-Benachrichtigung auf deinem Handy, mit dem Fehlertitel, dem Verursacher und einem Button, der das Issue öffnet. Kein Server, kein Code.

## Was du brauchst

- Eine Sentry-Organisation, in der du Integrationen und Alarme anlegen darfst.
- Ein Pocket-Alert-Konto mit der App auf deinem [iPhone oder Android](/get-app)-Handy. Der kostenlose Tarif enthält einen Webhook, mehr braucht dieses Setup nicht.
- Einen API-Schlüssel aus [API Keys](/account/apikeys), wenn du den Button „Open in Sentry“ willst (dazu weiter unten mehr).

## Wie Sentry Alarme an einen Webhook schickt

Sentry hat zwei Wege, einen Alarm per POST an eine URL zu schicken, und sie senden unterschiedliches JSON:

- **Interne Integration** (von Sentry empfohlen). Du legst eine private Integration mit einer Webhook-URL an und aktivierst den Schalter **Alert Action**. Danach taucht sie als Aktion in deinen Alarmen auf. Issue-Alarme kommen mit dem Header `Sentry-Hook-Resource: event_alert` und dem Fehler unter `data.event`. Alarme zu Issues aus Metric Monitors kommen als `metric_alert` mit einem fertigen Titel in `data.description_title`.
- **Webhooks (Legacy)**. Ein Plugin pro Projekt unter den Projekteinstellungen. Es funktioniert noch, aber die Einstellungsseite selbst sagt, dass Sentry stark zu einer internen Integration rät. Die Payload ist flach: `project_name`, `culprit`, `level`, `url`, `triggering_rules` und das rohe `event`.

Diese Anleitung nutzt die interne Integration. Am Ende gibt es ein Template für den Legacy-Webhook.

## Schritt 1: Den Pocket-Alert-Webhook anlegen

Pocket Alert nennt jede Push eines Webhooks `Webhook <name>`. Nenne ihn also **Sentry**, dann steht auf dem Sperrbildschirm „Webhook Sentry“. Der Textkörper kommt aus einem Template, das Felder aus dem Sentry-JSON mit `%path%`-Platzhaltern herausholt.

Am schnellsten geht es mit einem einzigen API-Aufruf, denn das Template für den Aktionsbutton lässt sich nur über die API setzen. Der Aufruf legt den Webhook mit dem Nachrichten-Template, einem Standard-Level und einem Button „Open in Sentry“ an und gibt danach die Empfangs-URL aus:

```bash
jq -n \
  --arg msg $'%data.event.title%%data.description_title%\n%data.event.culprit%%data.description_text%\nRule: %data.triggered_rule%' \
  --arg act '[{"type":"view","label":"Open in Sentry","value":"%data.event.web_url%%data.web_url%"}]' \
  '{name: "Sentry", message: $msg, default_level: 1, actions: $act}' |
curl -sS https://api.pocketalert.app/v1/webhooks \
  -H "Token: YOUR_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary @- |
jq -r '"Receive URL: https://p4a.me/wh/" + .url'
```

Das Template sieht absichtlich merkwürdig aus. Eine Sentry-Integration hat eine Webhook-URL, und sowohl Issue- als auch Metrik-Alarme gehen dorthin. Ein Platzhalter, dessen Pfad in der Payload fehlt, wird als leerer String ausgegeben. Deshalb zeigt `%data.event.title%%data.description_title%` bei einem Issue-Alarm den Fehlertitel und bei einem Metrik-Alarm den Alarmtitel. Derselbe Trick sorgt in beiden Fällen für den richtigen Link am Button. Bei einem Issue-Alarm zeigt `Rule:` den Namen des Alarms, bei einem Metrik-Alarm bleibt die Zeile leer.

Wenn du lieber klickst, lege den Webhook in der Konsole unter [Webhooks](/webhooks) an: Name **Sentry**, **Default priority** High, und füge das Nachrichten-Template ein:

```text
%data.event.title%%data.description_title%
%data.event.culprit%%data.description_text%
Rule: %data.triggered_rule%
```

Du bekommst dieselben Pushes, nur ohne den Button. Kopiere die Empfangs-URL, die die Konsole anzeigt (`https://p4a.me/wh/...`).

## Schritt 2: Die interne Integration in Sentry anlegen

1. Gehe in Sentry zu **Settings > Developer Settings**, lege eine neue Integration an und wähle **Internal Integration**.
2. Gib ihr einen Namen wie „Pocket Alert“.
3. Füge die Empfangs-URL in **Webhook URL** ein.
4. Aktiviere **Alert Action**. Dieser Schalter bringt die Integration in den Alarm-Builder.
5. Speichere. Interne Integrationen installieren sich selbst in deiner Organisation, ein OAuth-Schritt entfällt.

Lass die übrigen Webhook-Abos (Issue, Error, Comment) deaktiviert. Pocket Alert macht aus jeder empfangenen Anfrage eine Push, und diese Ressourcen kämen als Pushes mit meist leeren Zeilen an.

## Schritt 3: Alarme an den Webhook schicken

Der aktuelle Alarm-Builder von Sentry liegt unter **Monitors > Alerts > Create Alert**:

1. **Source**: die Projekte, die dich interessieren, oder bestimmte Monitore.
2. **Environment**: wähle `production`, damit Staging-Rauschen nicht auf dein Handy kommt.
3. **When**: „A new issue is created“ ist die klassische Wahl. „An issue escalates“ und „A resolved issue regresses“ lohnen sich zusätzlich.
4. **Then**: **Send a notification via an integration**, und wähle die Integration „Pocket Alert“.
5. **Throttling**: setze etwa 30 Minuten, damit ein heißes Issue nicht für jedes Event eine Push auslöst.

Klicke vor dem Speichern im If/Then-Block auf **Send Test Notification**. Eine Push mit dem Titel „Webhook Sentry“ sollte innerhalb von ein bis zwei Sekunden auf deinem Handy landen.

## Was auf deinem Handy ankommt

Bei einem Issue-Alarm trägt die Sentry-Payload den Fehler unter `data.event`. Das sind die Felder, die das Template nutzt, aus Sentrys dokumentierter `event_alert`-Payload:

<div class="cmp-table-wrap">
<table class="cmp-table">
<thead><tr><th>Feld</th><th>Beispiel</th><th>Verwendet für</th></tr></thead>
<tbody>
<tr><th><code>data.event.title</code></th><td>ReferenceError: heck is not defined</td><td>Erste Zeile der Push</td></tr>
<tr><th><code>data.event.culprit</code></th><td>wo der Fehler ausgelöst wurde</td><td>Zweite Zeile</td></tr>
<tr><th><code>data.triggered_rule</code></th><td>Very Important Alert!</td><td>Welcher Alarm ausgelöst hat</td></tr>
<tr><th><code>data.event.web_url</code></th><td>https://sentry.io/organizations/…/issues/…/events/…/</td><td>Button „Open in Sentry“</td></tr>
<tr><th><code>data.event.level</code></th><td>error</td><td>Optional, siehe unten</td></tr>
</tbody>
</table>
</div>

Ein Metrik-Alarm hat kein `data.event`. Sein `action` ist `critical`, `warning` oder `resolved`, und `data.description_title` enthält den Status bereits, zum Beispiel „Resolved: Too many errors“, darunter steht `data.description_text` („1000 events in the last 10 minutes“). Der Button nutzt `data.web_url`.

Willst du das Sentry-Level im Text haben? Ergänze `Level: %data.event.level%` im Template. Das ist nur Text. Der nächste Abschnitt erklärt, warum das nichts daran ändert, wie laut die Push ankommt.

## Level: Was tatsächlich bestimmt, wie laut die Push ist

Pocket Alert hat fünf Level: silent, low, default, high und critical. Bei Webhooks wird das Level in dieser Reihenfolge gewählt: ein Feld `level` auf oberster Ebene im eingehenden JSON, dann das Standard-Level des Webhooks, dann das Standard-Level der Anwendung.

Sentry lässt sich davon nicht allein abbilden, und ein Template kann keine Werte umrechnen:

- Die Payload der internen Integration hat kein `level` auf oberster Ebene. Das Level von Sentry steckt in `data.event.level`, also verwendet Pocket Alert das **Standard-Level** des Webhooks. Deshalb wird der Webhook oben mit `default_level: 1` (high) angelegt. Auf dem iPhone erscheint das als zeitkritische Benachrichtigung, die durch Fokus durchkommt.
- Der Legacy-Webhook sendet zwar ein `level` auf oberster Ebene, aber mit Sentry-Werten: `fatal`, `error`, `warning`, `info`, `debug`. Keiner davon ist ein Pocket-Alert-Level. Der Wert wird ignoriert, es gilt das Standard-Level. Der Alarm wird trotzdem zugestellt.

Wenn ein fataler Fehler in Production dich wecken soll, während alles andere auf high bleibt, trenne das auf der Sentry-Seite. Im bezahlten Tarif legst du einen zweiten Pocket-Alert-Webhook namens „Sentry critical“ mit `default_level: 2` an, dazu eine zweite interne Integration, die darauf zeigt. Dann nutzt du zwei If/Then-Blöcke im selben Alarm:

- Block 1: **If none** of: Event level equals `fatal`. **Then** notify the „Pocket Alert“ integration.
- Block 2: **If all** of: Event level equals `fatal`. **Then** notify „Pocket Alert critical“.

Kritische Alarme kommen auf iOS und Android durch „Nicht stören“ durch (siehe [Prioritätsstufen](https://info.pocketalert.app/features/priority-levels)). Das ist ein Feature des bezahlten Tarifs: Im kostenlosen Tarif wird critical als high zugestellt.

## Der Legacy-Webhook, falls du ihn schon nutzt

Projekte, bei denen **Webhooks (Legacy)** unter **Project Settings > Legacy Integrations** aktiviert ist, können auf dieselbe Art von Pocket-Alert-Webhook zeigen. Die Payload ist anders, deshalb nutze dieses Template:

```text
%project_name%: %event.title%
%culprit%
Rule: %triggering_rules.0%
```

Und dieses Button-Template für den oben genannten API-Aufruf:

```json
[{ "type": "view", "label": "Open in Sentry", "value": "%url%" }]
```

Nutze `%event.title%` statt des obersten `%message%`. In der Legacy-Payload ist `message` die Log-Nachricht des Events, und die ist bei einer gewöhnlichen Exception leer. Das Legacy-Plugin sendet nur, wenn ein Alarm die Aktion hat, die die Legacy-Integrationen des Projekts benachrichtigt. Die Einstellungsseite hat dafür einen Button **Send Test Event**.

## Ehrliche Grenzen

- **Ein Titel für alles.** Pocket Alert setzt als Titel bei Webhook-Pushes `Webhook <name>`, der Fehler landet im Textkörper. Wenn du den Fehler als Push-Titel brauchst, schalte eine kleine Funktion zwischen Sentry und die [Messages-API](https://info.pocketalert.app/api/messages/create).
- **Keine Signaturprüfung.** Interne Integrationen signieren Anfragen mit `Sentry-Hook-Signature`, Pocket Alert prüft diese Signatur nicht. Die zufällige Empfangs-URL ist das Geheimnis, also veröffentliche sie nicht. Wenn sie leakt, lösche den Webhook und lege einen neuen an.
- **Nur JSON.** Beide Sentry-Mechanismen senden JSON, hier passt das. Ein Absender mit form-encoded Daten würde aber abgewiesen.
- **Tageslimits.** Der kostenlose Tarif liefert 50 Nachrichten pro Tag. Mit aktiviertem Throttling und Alarmen nur für Production reicht das locker. Ein Alarm auf „every event captured“ verbraucht es dagegen schnell.

## Wenn nichts ankommt

- **Öffne den Webhook-Verlauf.** Jede Anfrage an deinen Pocket-Alert-Webhook wird mit Headern, Body, der gerenderten Nachricht und dem Status protokolliert. Ist die Anfrage da, liegt das Problem am Template. Ist sie nicht da, hat Sentry sie nie gesendet.
- **Prüfe den Schalter Alert Action.** Ohne ihn erscheint die Integration nicht unter **Send a notification via an integration**.
- **Prüfe den Verlauf des Alarms.** Die Detailseite des Alarms in Sentry listet die letzten Ausführungen. Filter wie Environment oder Event-Level schließen das erwartete Event oft aus.
- **Leere Zeilen in der Push** bedeuten, dass ein Pfad nicht zur Payload passt. Vergleiche ihn mit dem Body im Webhook-Verlauf, Feldnamen sind case-sensitiv.
- **Kein Button** bedeutet, dass der URL-Pfad leer war. Ein ungültiger Button wird verworfen, die Nachricht wird trotzdem zugestellt.

## FAQ

### Muss ich Code schreiben?

Nein. Sentry sendet den Webhook, und Pocket Alert macht daraus eine Push. Der einzige Befehl in dieser Anleitung ist der optionale API-Aufruf, der den Button „Open in Sentry“ ergänzt.

### Kann ich Production und Staging trennen?

Ja. Filtere den Alarm nach Environment oder lege pro Environment einen Alarm an, der auf verschiedene Integrationen und Webhooks zeigt. Jeder landet in einer eigenen Pocket-Alert-Anwendung, damit du Staging gezielt stummschalten kannst.

### Funktioniert das mit selbst gehostetem Sentry?

Die interne Integration und die Alert Action sind Teil von Sentry selbst. Eine selbst gehostete Installation, die aktuell genug ist, um sie zu haben, kann genauso an Pocket Alert senden, solange sie `p4a.me` über das Internet erreichen kann.

### Was ist mit Rollbar, Bugsnag und anderen Trackern?

Derselbe Ansatz funktioniert mit jedem Tracker, der JSON an eine URL sendet. Nur die Template-Pfade ändern sich. Das größere Bild findest du unter [Fehler-Tracking-Alarme](/use-cases/error-tracking-alerts). Für die Funktionsweise der Templates siehe das [Webhook-Tool](/tools/webhook) und die [Template-Syntax](https://info.pocketalert.app/api/webhooks/settings).

### Ist das kostenlos?

Der kostenlose Tarif von Pocket Alert umfasst einen Webhook, ein Gerät und 50 Nachrichten pro Tag. Das reicht für Production-Fehleralarme in einer kleinen App.

[Kostenloses Konto erstellen](/signup), die URL in Sentry eintragen, und der nächste Fehler in Production erreicht dich zuerst.
