# Webhooks, Zapier, API und KI-Assistenten anbinden

> Webhook einrichten und absichern, fehlgeschlagene Aufrufe nachvollziehen, Zapier verbinden, die API mit einem Schlüssel ansprechen und einen KI-Assistenten per MCP andocken.

https://rabbit-checkout.de/hilfe/anleitungen/webhooks-und-api/ · Aktualisiert: 2026-08-04

---


Vier Wege, Rabbit Checkout mit anderen Systemen zu verbinden, vom einfachsten
zum flexibelsten.

## Webhooks

Ein Webhook ruft eine Adresse bei dir auf, sobald etwas passiert.

### Einrichten

1. **Einstellungen → Webhooks** → **Neu**.
2. **Webhook-Name** vergeben (nur zur Orientierung).
3. **Webhook-Endpunkt** eintragen: die Adresse, die aufgerufen werden soll.
4. Unter **Webhook-Ereignisse** auswählen, worauf reagiert werden soll.
5. Optional ein **Secret** hinterlegen (siehe unten).
6. **Speichern**.

Pro Shop darf jede Endpunkt-Adresse nur einmal vorkommen. Mit dem Schalter
**Aktiviert** kannst du einen Webhook stilllegen, ohne ihn zu löschen.

### Die Ereignisse

| Ereignis | Wann |
| --- | --- |
| `ORDER_CREATED` | Bestellung angelegt |
| `ORDER_PAYED` | Zahlung bestätigt |
| `ORDER_REFUNDED` | Erstattung ausgeführt |
| `ORDER_FAILED` | Zahlung gescheitert |
| `SUBSCRIPTION_CREATED` | Abo angelegt |
| `SUBSCRIPTION_ACTIVATED` | Abo aktiv |
| `SUBSCRIPTION_PAUSED` | Abo pausiert |
| `SUBSCRIPTION_CANCELED` | Abo gekündigt |
| `SUBSCRIPTION_EXPIRED` | Abo ausgelaufen |
| `PRODUCT_ACCESS_GRANTED` | Produktzugang freigeschaltet |
| `PRODUCT_ACCESS_REVOKED` | Produktzugang entzogen |

Für „jemand hat gekauft und soll jetzt etwas bekommen" ist meist `ORDER_PAYED`
oder `PRODUCT_ACCESS_GRANTED` das richtige Ereignis, nicht `ORDER_CREATED`, denn
zu diesem Zeitpunkt ist noch kein Geld geflossen.

### Signatur prüfen

Hinterlegst du ein **Secret**, schickt Rabbit Checkout bei jedem Aufruf den
Header:

```
x-signature: <HMAC-SHA256 über den Rohkörper, hex>
```

Berechne dieselbe Signatur mit deinem Secret über den **unveränderten**
Anfragekörper und vergleiche. In Node.js:

```js
const crypto = require('node:crypto')

const expected = crypto
  .createHmac('sha256', SECRET)
  .update(rawBody)          // der Rohkörper, nicht das geparste JSON
  .digest('hex')

const ok = expected === request.headers['x-signature']
```

<div class="docs-warn">
Ohne Secret ist dein Endpunkt für jeden aufrufbar, der die Adresse kennt.
Wenn der Webhook etwas auslöst, das Geld oder Zugang bedeutet, hinterlege ein
Secret und prüfe die Signatur.
</div>

### Wiederholungen und Fehlersuche

Antwortet dein Endpunkt nicht mit Erfolg, wird der Aufruf **bis zu dreimal**
mit wachsendem Abstand wiederholt. Bleibt es erfolglos, bekommst du eine
Benachrichtigung („Webhook-Aufruf fehlgeschlagen"), sofern unter
**Einstellungen → Benachrichtigungen** aktiviert.

Unter **Einstellungen → Ereignisse** siehst du jedes Ereignis mit seinen
Zustellversuchen: Ziel-Adresse, gesendeter Inhalt, Antwortstatus und
Antworttext. Von dort lässt sich ein Aufruf auch erneut auslösen.

<div class="docs-note">
Testbestellungen erzeugen ganz normale Ereignisse. Im Datensatz steht
<code>isTest</code>, filtere darauf, wenn deine Automatisierung
Testbestellungen ignorieren soll →
<a href="/hilfe/grundlagen/checkout-flow-status/">Status Test, Live,
Deaktiviert</a>.
</div>

## Zapier

Rabbit Checkout hat eine Zapier-App. Verbunden wird sie mit einem **API-Key**
(siehe unten).

Als Auslöser stehen zur Verfügung:

- **Produktzugang erteilt**
- **Produktzugang entzogen**

Das deckt den häufigsten Fall ab: „Kunde hat gekauft → trag ihn in mein
E-Mail-Tool ein". Für alles Darüberhinausgehende sind Webhooks der flexiblere
Weg: Die meisten Automatisierungswerkzeuge (Zapier, Make, n8n) können einen
Webhook als Auslöser entgegennehmen.

## API

1. Im Dashboard oben rechts über das Menü zu **Konto**.
2. **API-Key erstellen** und den Schlüssel sicher notieren.
3. Den Schlüssel gegen ein Zugriffstoken tauschen:

```http
POST https://dashboard.rabbit-checkout.de/api/auth/token
Content-Type: application/json

{ "apiKey": "DEIN_API_KEY" }
```

4. Weitere Aufrufe mit dem Token:

```http
GET https://dashboard.rabbit-checkout.de/api/stores
Authorization: Bearer DEIN_TOKEN
```

Die vollständige, immer aktuelle Referenz mit allen Endpunkten und Feldern liegt
unter:

```
https://dashboard.rabbit-checkout.de/api/docs
```

<div class="docs-note">
Die öffentlich dokumentierte API ist bewusst schlank: Konto, Stores,
Store-Adresse, Produktzugänge und die Verwaltung von Webhooks. Für Reaktionen
auf Verkäufe sind Webhooks der vorgesehene Weg, nicht regelmäßiges Abfragen.
</div>

## KI-Assistenten anbinden (MCP)

Rabbit Checkout stellt einen **MCP-Server** bereit, mit dem ein KI-Assistent
Daten deines Shops lesen kann.

1. Im Dashboard **Einstellungen → Integrationen → Model Context Protocol (MCP)**
   (oder **Einstellungen → Laden-URLs**), dort steht die **MCP-Server-URL**:
   `https://dashboard.rabbit-checkout.de/api/mcp`
2. Diese Adresse im Assistenten als eigenen Connector eintragen, in Claude
   unter *Einstellungen → Connectors*, in ChatGPT ebenfalls unter
   *Einstellungen → Connectors*.
3. Der Assistent leitet dich zur Anmeldung. Dort wählst du den Shop aus und
   bestätigst den Zugriff.

Unter **Integrationen → MCP-Verbindungen** siehst du alle verbundenen
Assistenten und kannst jede Verbindung einzeln widerrufen. Der Zugriff endet
dann sofort.

<div class="docs-note">
Der Umfang ist heute bewusst klein: lesender Zugriff auf Produkte. Der
Assistent kann in deinem Shop nichts verändern.
</div>

### Fragen zur Bedienung beantworten lassen

Wenn du deinen Assistenten stattdessen zu **Anleitungen** befragen willst
(„Wie erstelle ich einen Gutschein?"), brauchst du keinen Connector. Gib ihm
diese Adresse:

```
https://rabbit-checkout.de/llms.txt
```

Dort stehen alle Hilfeseiten als reines Markdown verlinkt. Der Assistent liest
sich von dort weiter. Einzelseiten gibt es jeweils auch direkt, etwa
`https://rabbit-checkout.de/hilfe/anleitungen/gutschein-erstellen.md`.


## Häufige Fragen

**Wie richte ich einen Webhook in Rabbit Checkout ein?**

Einstellungen → Webhooks → Neu. Name, Endpunkt-URL und die Ereignisse auswählen, auf die reagiert werden soll. Optional ein Secret hinterlegen, mit dem jede Anfrage signiert wird.

**Wie prüfe ich, ob ein Webhook-Aufruf echt ist?**

Hinterlege ein Secret. Rabbit Checkout schickt dann den Header x-signature mit einer HMAC-SHA256-Signatur über den Rohkörper der Anfrage. Berechne dieselbe Signatur mit deinem Secret und vergleiche.

**Was passiert, wenn mein Endpunkt nicht erreichbar ist?**

Der Aufruf wird bis zu dreimal mit wachsendem Abstand wiederholt. Bleibt er erfolglos, wirst du benachrichtigt, und der Versuch ist unter Ereignisse einsehbar.

**Wie erkenne ich Testbestellungen in einem Webhook?**

Im Datensatz steht das Merkmal isTest. Filtere darauf, wenn deine Automatisierung Testbestellungen ignorieren soll.

**Gibt es eine API?**

Ja. Du erzeugst im Dashboard unter Konto einen API-Key, tauschst ihn gegen ein Zugriffstoken und rufst die Endpunkte mit Bearer-Token auf. Die Referenz liegt unter https://dashboard.rabbit-checkout.de/api/docs.


## Passend dazu

- [Referenz: Status und Ereignisse](https://rabbit-checkout.de/hilfe/referenz/status-und-ereignisse/)
- [Anleitung: sevDesk und Lexware anbinden](https://rabbit-checkout.de/hilfe/anleitungen/buchhaltung-sevdesk-lexware/)