# OnlyFans-CRM mit der API bauen: Datenmodell, Webhooks und Sync

> So baust du ein OnlyFans-CRM: sichere Authentifizierung, relationales Datenmodell, Import historischer Daten und Webhook-Sync nahezu in Echtzeit.

**Kurz gesagt**

- Ein vollständiges Datenmodell für ein OnlyFans-CRM trennt mandantenfähige Agentur-Accounts, die einzelnen Creator-Rosters, Fan-Profile, Konversationen und Finanz-Ledger.
- Die Authentifizierung basiert auf eingebetteten Client-Sessions: Creator melden sich mit E-Mail, Passwort und 2FA in einem sicheren Modal an.
- Der initiale Datenbestand wird befüllt, indem du die Listen-Endpunkte für Fans, Chats und Einnahmenverläufe paginierst.
- Die laufende Synchronisierung läuft über Webhooks (ab dem Basic-Plan) wie `messages.received` und `transactions.new` und ersetzt Polling, das viel Rate Limit verbraucht.

Für ein OnlyFans-CRM brauchst du eine relationale Datenbank, in der Accounts, Fans, Chats und Transaktionen gespeichert werden, kombiniert mit einem Import der historischen Daten und eventbasierten Webhooks, die das System synchron halten. Entwickler bauen diese Backend-Architektur, indem sie Creator über sichere Modals authentifizieren, historische Datensätze über REST-Listen-Endpunkte abrufen und Zustandsänderungen live über Webhooks nahezu in Echtzeit (ab dem Basic-Plan) verarbeiten.

**Das Wichtigste in Kürze**

- Ein vollständiges Datenmodell für ein OnlyFans-CRM trennt mandantenfähige Agentur-Accounts, die einzelnen Creator-Rosters, Fan-Profile, Konversationen und Finanz-Ledger.
- Die Authentifizierung basiert auf eingebetteten Client-Sessions: Creator melden sich mit E-Mail, Passwort und 2FA in einem sicheren Modal an.
- Der initiale Datenbestand wird befüllt, indem du die Listen-Endpunkte für Fans, Chats und Einnahmenverläufe paginierst.
- Die laufende Synchronisierung läuft über Webhooks (ab dem Basic-Plan) wie `messages.received` und `transactions.new` und ersetzt Polling, das viel Rate Limit verbraucht.

## Wie baue ich ein OnlyFans-CRM mit einer API?

Um ein eigenes OnlyFans-CRM mit einer API zu bauen, richtest du die eingebettete Authentifizierung ein, entwirfst ein relationales Datenmodell für Fans und Transaktionen, importierst die historischen Daten über REST-Listen-Endpunkte und abonnierst Webhooks nahezu in Echtzeit (ab dem Basic-Plan) für die laufende Synchronisierung.

1. **Authentifizierung und Account-Verbindung**: Bette mit dem Paket `@onlyfansapi/auth` ein sicheres Login-Modal ein.
2. **Relationales Datenmodell**: Lege Tabellen für Creator-Accounts, Ausgabenprofile der Abonnenten, Chat-Threads und Transaktions-Ledger an.
3. **Import historischer Daten**: Paginiere Endpunkte wie `GET https://app.fansapi.com/api/{account}/fans/all`, um deine internen Datenbanken mit historischen Profilen und Chatverläufen zu befüllen.
4. **Webhook-Synchronisierung nahezu in Echtzeit**: Verarbeite Events wie `messages.received` und `transactions.new`, um den Datenbankzustand ohne dauerhaftes Polling zu aktualisieren.

## Das relationale Datenmodell entwerfen

Ein CRM-Datenmodell trennt mandantenfähige Agentur-Accounts von den einzelnen Creator-Rosters, den Profilen der Fan-Beziehungen, chronologischen Konversationen und Finanz-Ledgern. Engineering-Teams, die eigene Software entwickeln, wie in unserem Ratgeber zu [OnlyFans-CRM und Agentur-Software](/de/blog/onlyfans-crm-agentur-software-vergleich) beschrieben, brauchen direkte programmatische Kontrolle über diese Entitäten.

**Zentrale Datenentitäten**

- **Creator-Accounts**: Speichert die Creator-Metadaten und den Verbindungsstatus der Session. Verwende die `onlyfans_id` des Creators als Schlüssel des Datensatzes: Ein neu verbundener Creator bekommt eine neue `acct_`-ID.
- **Fans**: Bündelt Abonnenten-Metadaten, die Aufschlüsselung der Gesamtausgaben, eigene Notizen und CRM-Tags.
- **Chats und Nachrichten**: Speichert Konversations-Threads, die Richtung der Nachrichten, PPV-Status und die IDs angehängter CDN-Medien.
- **Transaktionen**: Führt einen unveränderlichen Nachweis aller Geldereignisse für Provisionsauszahlungen und Attribution.

| Feldname | Typ | Beschreibung |
| --- | --- | --- |
| `id` | `VARCHAR(64)` | Nutzer-ID des Abonnenten (`fan.id`) |
| `account_id` | `VARCHAR(64)` | Zugeordnete Creator-Account-ID, beginnt mit `acct_` |
| `total_spent` | `DECIMAL(12,2)` | Gesamtausgaben (`totalSumm` / `spending.total`) |
| `messages_spent` | `DECIMAL(12,2)` | Ausgaben für bezahlte Nachrichten (`messagesSumm` / `spending.messages`) |
| `subscribes_spent` | `DECIMAL(12,2)` | Ausgaben für Abos (`subscribesSumm` / `spending.subscribes`) |

## Eingebettete Authentifizierung und Account-Verbindung

Agenturen und Entwickler bauen sichere Onboarding-Flows, indem sie das offizielle NPM-Paket `@onlyfansapi/auth` integrieren. Der Creator meldet sich mit E-Mail, Passwort und 2FA in unserem sicheren Modal an.

Das Backend erzeugt über `POST https://app.fansapi.com/api/client-sessions` ein [Client-Session-Token](https://docs.fansapi.com/api-reference/client-sessions/create-client-session). Das Frontend öffnet das Modal anschließend mit `startOnlyFansAuthentication`. Nach erfolgreicher 2FA gibt das Modal eine `accountId` im Format `acct_XXXX` zurück, die den Creator mit dem Mandanten im CRM verknüpft.

## Initialer Import historischer Daten über Listen-Endpunkte

Sobald ein Account verbunden ist, führt das CRM eine erste Synchronisierung der historischen Daten aus, um die Datenbank zu befüllen, bevor es sich auf Webhooks verlässt. Wie auf unserer Seite zur [OnlyFans-CRM-API](https://fansapi.com/onlyfans-crm-api) beschrieben, durchläuft dieser Prozess Abonnenten, Konversationen, Nachrichtenverläufe und vergangene Transaktionen.

### Abonnenten und Ausgabenprofile paginieren

[Rufe alle aktiven und abgelaufenen Fans](https://docs.fansapi.com/api-reference/fans/list-all-fans) per Offset-Paginierung ab, um die vollständige finanzielle Aufschlüsselung zu erfassen.

```typescript
export async function backfillFans(accountId: string, apiKey: string) {
  let offset = 0;
  const limit = 20;
  let hasMore = true;

  while (hasMore) {
    const url = `https://app.fansapi.com/api/${accountId}/fans/all?limit=${limit}&offset=${offset}`;
    const res = await fetch(url, {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    });

    const result = await res.json();
    const fans = result.data?.list ?? [];

    // Hier kommt die Upsert-Logik für jedes Fan-Profil und seine Ausgabendaten hin

    hasMore = result.data?.hasMore === true;
    offset += limit;
  }
}
```

## Synchronisierung nahezu in Echtzeit über Webhooks

Dauerhaftes Polling von APIs schöpft die Rate Limits aus und führt zu Verzögerungen bei der Synchronisierung. Webhooks liefern [Nachrichten- und Transaktions-Events](https://docs.fansapi.com/webhooks/available-events) nahezu in Echtzeit (`transactions.new` kann bis zu 3 Minuten verzögert sein). Webhooks und die dedizierte mobile Proxy-Infrastruktur gibt es ab dem Basic-Plan ($69/Monat). OnlyFansAPI bietet Zugriff auf über 320 Endpunkte, hat mehr als 300 Millionen API-Anfragen und Webhooks verarbeitet und wird von über 1.100 Unternehmen genutzt.

### Katalog der wichtigsten Webhook-Events

- `accounts.connected`: Wird ausgelöst, wenn ein Creator den Auth-Flow abschließt.
- `messages.received`: Eingehende Nachricht von einem Fan.
- `messages.ppv.unlocked`: Ein Fan kauft eine PPV-Nachricht, die du gesendet hast.
- `subscriptions.new`: Ein neuer Abonnent kommt hinzu.
- `subscriptions.renewed`: Das Abo eines Abonnenten wird erneut abgerechnet.
- `subscriptions.expired`: Ein Abo läuft ab.
- `transactions.new`: Jede Zahlung, etwa Trinkgelder, Posts oder Abos.

Webhook-Router müssen diese Events verarbeiten, um die CRM-Datenbank zu aktualisieren.

```typescript
export async function handleOnlyFansWebhook(req: Request, res: Response) {
  // Prüfe zuerst den Signature-Header (HMAC SHA256 des Raw Body) und überspringe wiederholte X-OFAPI-Idempotency-Key-Werte
  const { event, account_id, payload } = req.body;
  res.status(200).json({ received: true });

  if (event === 'messages.received') {
    // Nachricht in die CRM-Datenbank einfügen und Ungelesen-Zähler aktualisieren
  } else if (event === 'transactions.new') {
    // Finanzereignis im Ledger erfassen
  }
}
```

## CRM-Aktionen ausführen und ausgehende Synchronisierung

Um als operatives CRM zu funktionieren, führt das System ausgehende Aktionen zurück auf der Plattform aus. OnlyFansAPI leitet diese Anfragen über eine dedizierte mobile IP pro verbundenem OnlyFans-Account (USA oder UK, ab dem Basic-Plan), ohne Rotation. OnlyFansAPI hat in über 5 Jahren null Sperren verzeichnet.

### Ausgehende Nachrichten und PPVs senden

Ausgehende Chat-Nachrichten unterstützen reinen Text, hochgeladene CDN-Mediendateien und PPV-Preise. Bezahlte Nachrichten brauchen einen Preis zwischen 3 und 200 und erfordern `mediaFiles`, außer `lockedText` ist true. Massennachrichten haben keinen Testlauf (Dry Run).

```typescript
export async function sendCrmReply(
  accountId: string,
  chatId: string,
  text: string,
  price: number = 0,
  apiKey: string,
  mediaFiles: string[] = []
) {
  const payload: any = { text };
  if (price > 0) {
    payload.price = price;
    payload.mediaFiles = mediaFiles; // Pflicht für bezahlte Nachrichten, außer lockedText ist true
  }

  const msgRes = await fetch(`https://app.fansapi.com/api/${accountId}/chats/${chatId}/messages`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(payload)
  });

  return await msgRes.json();
}
```

### Fan-Notizen und Segmentierung aktualisieren

Mit einem eigenen CRM pflegen Betreiber dauerhafte Notizen und Segmentlisten, die direkt synchronisiert werden. Entwickler können die Notizen zu einem Fan im Creator-Account anlegen oder bearbeiten, indem sie `PUT https://app.fansapi.com/api/{account}/fans/{fan_id}/notes` aufrufen (Body-Feld `notes`), und Fans mit `POST https://app.fansapi.com/api/{account}/user-lists/{userListId}/users` zu einer OnlyFans-Liste hinzufügen.

Mit einem eigenen internen Tool haben Agenturen ihre Datenschicht vollständig unter Kontrolle. Durch die Kombination aus eingebetteter Authentifizierung, Import über Listen-Endpunkte und Webhook-Verarbeitung nahezu in Echtzeit bauen Entwicklungsteams skalierbare Anwendungen, gestützt auf 99,98 % Uptime.