# OnlyFans-Willkommensnachricht bei neuem Abo automatisch senden (subscriptions.new-Webhook)

> So sendest du eine OnlyFans-Willkommensnachricht automatisch mit dem subscriptions.new-Webhook: Events nahezu in Echtzeit statt manuellem Polling.

**Kurz gesagt**

- Der Webhook `subscriptions.new` (ab dem Basic-Plan) wird nahezu in Echtzeit ausgelöst, wenn ein neuer Fan abonniert.
- Nutze als `chat_id` für deine API-Antwort die ID des Fans aus dem `user`- (oder `fan`-)Objekt der Payload, nicht die `user_id` auf oberster Ebene (das ist der verbundene Creator).
- Automatisierte bezahlte Willkommensnachrichten erfordern einen Preis zwischen 3 und 200 und ein befülltes `mediaFiles`-Array, außer `lockedText` ist true.
- Webhook-Events nahezu in Echtzeit ersetzen das regelmäßige Polling von Abonnentenlisten.
- Agenturen können Willkommenssequenzen mit eigenem Backend-Code oder mit unseren eigenen No-Code-Paketen für Zapier, Make und n8n umsetzen.

Um automatisch eine OnlyFans-Willkommensnachricht zu senden, wenn jemand abonniert, können Entwickler auf das Webhook-Event `subscriptions.new` hören und eine POST-Anfrage an die Chat-Messages-API auslösen. [OnlyFansAPI](https://fansapi.com) bietet diesen Webhook ab dem Basic-Plan an. So gehen kostenlose Begrüßungen oder gesperrte Pay-per-View-Medien (PPV) nahezu in Echtzeit raus, nachdem ein Fan abonniert hat.

**Das Wichtigste in Kürze**

- Der Webhook `subscriptions.new` (ab dem Basic-Plan) wird nahezu in Echtzeit ausgelöst, wenn ein neuer Fan abonniert.
- Nutze als `chat_id` für deine API-Antwort die ID des Fans aus dem user- (oder fan-)Objekt der Payload, nicht die `user_id` auf oberster Ebene (das ist der verbundene Creator).
- Automatisierte bezahlte Willkommensnachrichten erfordern einen Preis zwischen 3 und 200 und ein befülltes `mediaFiles`-Array, außer `lockedText` ist true.
- Webhook-Events nahezu in Echtzeit ersetzen das regelmäßige Polling von Abonnentenlisten.
- Agenturen können Willkommenssequenzen mit eigenem Backend-Code oder mit unseren eigenen No-Code-Paketen für Zapier, Make und n8n umsetzen.

## So löst du Webhooks bei neuen Abonnenten aus

Um Webhooks bei neuen Abonnenten auszulösen, richtest du einen Endpunkt ein, der das Event `subscriptions.new` empfängt. Dieses sendet nahezu in Echtzeit nach dem Abschluss des Abos eine HTTP-POST-Anfrage mit den Daten des neuen Abonnenten. Entwickler richten eine Server-URL ein, die diese Payload empfängt, prüfen das eingehende Event und lesen die User-ID des Fans aus, um Folgeaktionen auszulösen, etwa das Senden einer automatisierten Willkommensnachricht.

Dieser eventgesteuerte Ansatz ersetzt das manuelle Polling paginierter Abonnentenlisten. Um auf `subscriptions.new` zu hören, brauchst du den Basic-Plan ($69/Monat) oder höher, da der Free-Plan keine Webhooks enthält.

## Polling vs. Push nahezu in Echtzeit

Eine wichtige technische Trennlinie im Creator-Betrieb ist die Frage, wie Systeme neue Abonnenten erkennen.

| Architekturkriterium | Regelmäßiges Polling | Push nahezu in Echtzeit (`subscriptions.new`) |
| --- | --- | --- |
| **Erkennungsgeschwindigkeit** | Hängt von deinem Polling-Intervall ab | Zustellung nahezu in Echtzeit |
| **Credit-Effizienz** | 1 Credit pro nicht gecachter Anfrage, bei jedem Poll | 1 Credit pro 100 Webhook-Events |
| **Deduplizierung** | Erfordert Diff-Protokolle in einer lokalen Datenbank | `X-OFAPI-Idempotency-Key`-Header pro Event |
| **Infrastruktur** | Aufwendige Cron-Schleifen | Eventgesteuerter Webhook-Handler |

Mit Webhooks geht die Willkommensnachricht nahezu in Echtzeit raus, nachdem der Fan abonniert hat.

## Regeln für bezahlte Nachrichten (PPV) in Automatisierungen

Wenn Entwickler einem neuen Abonnenten antworten, können sie kostenlosen Text senden oder gesperrten Pay-per-View-Content (PPV) anhängen. Die API setzt für diese Direktnachrichten bestimmte Regeln durch.

- **Preisvorgaben:** Bezahlte Direktnachrichten kosten 3 bis 200. Die API akzeptiert einen Preis von 0 (kostenlos) oder 3 bis 200 und lehnt jeden anderen Wert ab.
- **Pflicht zu Medien:** Jede bezahlte Nachricht mit einem Preis über 0 muss mindestens eine Mediendatei enthalten, außer `lockedText` ist true. Eine Payload mit Preis, leerem `mediaFiles`-Array und ohne `lockedText` liefert einen 422-Validierungsfehler.
- **Formate für Medien-IDs:** Der Parameter `mediaFiles` akzeptiert temporäre Upload-IDs, die über unsere API erzeugt werden (z. B. `ofapi_media_123`), und dauerhafte Vault-Medien-IDs (z. B. `3866342509`). Du kannst beide ID-Arten im selben Array kombinieren. In unserem [Ratgeber zu Medien-Uploads](https://docs.fansapi.com/introduction/guides/uploading-media) erfährst du, wie du die IDs ermittelst.
- **Kostenlose Vorschauen:** Um neben gesperrten Medien kostenlose Teaser anzubieten, übergib die Vorschau-IDs im Array `previews`. Jedes Medium im Array `previews` muss auch im Array `mediaFiles` enthalten sein.

## Die Payload des subscriptions.new-Webhooks

Wenn ein Fan abonniert, sendet der Server eine JSON-Payload mit den Event-Details und dem Profil des Abonnenten. Eine vollständige Liste der unterstützten Events und eine Anleitung zur Prüfung der HMAC-Signatur findest du in unserem [Ratgeber zu OnlyFans-Webhooks](https://fansapi.com/de/blog/onlyfans-webhooks-abonnenten-trinkgelder-nachrichten).

```json
{
  "event": "subscriptions.new",
  "account_id": "acct_123",
  "payload": {
    "id": "123",
    "type": "subscribed",
    "createdAt": "2026-10-04T12:00:00+00:00",
    "subType": "new_subscriber",
    "user_id": "222222222",
    "user": {
      "id": 987654321,
      "name": "Alex",
      "username": "alex99",
      "subscribePrice": 0,
      "isVerified": true,
      "canReceiveChatMessage": false
    }
  }
}
```

Die `user_id` in der Payload ist die ID des verbundenen Creators, nicht die des Abonnenten. Die ID des Abonnenten steht im user- (und fan-)Objekt und ist in der Regel auch seine Chat-ID für Direktnachrichten.

## Codebeispiele zur Implementierung

Du kannst mit den offiziellen SDKs oder mit direkten REST-Anfragen auf das Event hören und eine Willkommensnachricht auslösen. Webhooks werden mindestens einmal zugestellt, deshalb überspringen beide Beispiele Wiederholungen desselben Events anhand des Headers `X-OFAPI-Idempotency-Key`.

### Implementierung mit TypeScript und Node.js

```typescript
import express from 'express';
import OnlyFansAPI from '@onlyfansapi/onlyfans-sdk';

const app = express();
app.use(express.json());
const client = new OnlyFansAPI();
const seen = new Set<string>(); // in Produktion einen persistenten Speicher nutzen

app.post('/webhooks/onlyfans', async (req, res) => {
  const { event, account_id, payload } = req.body;
  const eventKey = req.header('X-OFAPI-Idempotency-Key');

  // Erst antworten, dann senden
  res.sendStatus(200);
  if (eventKey) {
    if (seen.has(eventKey)) return;
    seen.add(eventKey);
  }

  if (event === 'subscriptions.new') {
    const fanId = String(payload.user.id);

    try {
      await client.chats.messages.send(fanId, {
        account: account_id,
        text: 'Hey! Thanks for subscribing 💜 Check your DMs for a surprise.',
      });

      await client.chats.messages.send(fanId, {
        account: account_id,
        text: 'Here is an exclusive welcome video just for you.',
        price: 9.99,
        mediaFiles: ['3866342509']
      });
    } catch (error) {
      console.error('Failed to send message');
    }
  }
});

app.listen(3000, () => console.log('Listening on port 3000'));
```

### Implementierung mit Python

```python
import os
from fastapi import FastAPI, Request, Response
from onlyfansapi import OnlyFansAPI

app = FastAPI()
client = OnlyFansAPI()
seen = set()  # in Produktion einen persistenten Speicher nutzen

@app.post("/webhooks/onlyfans")
async def handle_webhook(request: Request):
    event_key = request.headers.get("X-OFAPI-Idempotency-Key")
    if event_key in seen:
        return Response(status_code=200)
    if event_key:
        seen.add(event_key)

    data = await request.json()
    event = data.get("event")
    account_id = data.get("account_id")
    payload = data.get("payload", {})

    if event == "subscriptions.new":
        fan = payload.get("user", {})
        fan_id = str(fan.get("id"))

        client.chats.messages.send(
            fan_id,
            account=account_id,
            text="Hey! Thanks for subscribing 💕",
        )

        client.chats.messages.send(
            fan_id,
            account=account_id,
            text="Unwrap your exclusive welcome gift.",
            price=5.00,
            media_files=["3866342509"],
        )

    return Response(status_code=200)
```

### Direkte REST-Anfrage

```bash
curl -X POST "https://app.fansapi.com/api/acct_123456789/chats/987654321/messages" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Welcome to my VIP page! Here is a welcome treat.",
    "price": 10,
    "mediaFiles": ["3866342509"]
  }'
```

## No-Code-Automatisierung für Willkommensnachrichten

Creator und Agenturbetreiber können diese Sequenzen ohne eigenen Code mit unseren [Integrationen für Zapier, Make und n8n](https://fansapi.com/no-code) aufbauen. Diese nativen Pakete verbinden sich direkt mit deinem Account. Abonnenten-Trigger laufen über Webhooks und setzen deshalb den Basic-Plan oder höher voraus.

- **Einrichtung in Zapier:** Wähle die App OnlyFans API und dann den Trigger New Subscriber. Unsere Zapier-App bietet nur Trigger, sende die Antwort also aus n8n, Make oder deinem eigenen Code.
- **Einrichtung in Make:** Füge den Trigger OnlyFans API New Subscription hinzu. Verbinde ein Modul Make a custom API call, das deinen Text und einen optionalen Preis an den Endpunkt Send Message sendet.
- **n8n (empfohlen):** Installiere unseren Community Node `@onlyfansapi/n8n-nodes-onlyfansapi`. Füge in n8n einen Webhook-Listener hinzu und richte einen `subscriptions.new`-Webhook auf dessen URL. Verzweige mit bedingter Logik nach dem Abo-Preis (`{PRICE}` in der Payload) und füge dann den Node OnlyFans API hinzu, um die Operation Send Message auszuführen.