# Message de bienvenue OnlyFans automatique à chaque abonnement (webhook subscriptions.new)

> Envoyez automatiquement un message de bienvenue OnlyFans avec le webhook subscriptions.new : des événements en quasi temps réel au lieu du polling manuel.

**En bref**

- Le webhook `subscriptions.new` (à partir du plan Basic) se déclenche en quasi temps réel lorsqu'un nouveau fan s'abonne.
- Utilisez comme `chat_id` de votre réponse API l'ID du fan issu de l'objet `user` (ou `fan`) du payload, et non le `user_id` de premier niveau (qui correspond au créateur connecté).
- Les messages de bienvenue payants automatisés exigent un prix compris entre 3 et 200 et un tableau `mediaFiles` renseigné, sauf si `lockedText` vaut true.
- Les événements webhook en quasi temps réel remplacent le polling périodique des listes d'abonnés.
- Les agences peuvent déployer des séquences de bienvenue avec du code backend sur mesure ou avec nos propres packages no-code pour Zapier, Make et n8n.

Pour envoyer automatiquement un message de bienvenue OnlyFans lorsqu'un fan s'abonne, les développeurs peuvent écouter l'événement webhook `subscriptions.new` et déclencher une requête POST vers l'API des messages de chat. [OnlyFansAPI](https://fansapi.com) fournit ce webhook à partir du plan Basic : les messages d'accueil gratuits ou les médias Pay-Per-View (PPV) verrouillés partent ainsi en quasi temps réel après l'abonnement du fan.

**Points clés**

- Le webhook `subscriptions.new` (à partir du plan Basic) se déclenche en quasi temps réel lorsqu'un nouveau fan s'abonne.
- Utilisez comme `chat_id` de votre réponse API l'ID du fan issu de l'objet user (ou fan) du payload, et non le `user_id` de premier niveau (qui correspond au créateur connecté).
- Les messages de bienvenue payants automatisés exigent un prix compris entre 3 et 200 et un tableau `mediaFiles` renseigné, sauf si `lockedText` vaut true.
- Les événements webhook en quasi temps réel remplacent le polling périodique des listes d'abonnés.
- Les agences peuvent déployer des séquences de bienvenue avec du code backend sur mesure ou avec nos propres packages no-code pour Zapier, Make et n8n.

## Comment déclencher des webhooks à chaque nouvel abonné

Pour déclencher des webhooks à chaque nouvel abonné, configurez un endpoint qui reçoit l'événement `subscriptions.new`. Celui-ci envoie une requête HTTP POST contenant les informations du nouvel abonné en quasi temps réel après son abonnement. Les développeurs configurent une URL de serveur pour recevoir ce payload, vérifient l'événement entrant et extraient l'ID utilisateur du fan pour déclencher les actions suivantes, comme l'envoi d'un message de bienvenue automatisé.

Cette approche événementielle remplace le polling manuel des listes d'abonnés paginées. Écouter `subscriptions.new` nécessite le plan Basic ($69/mois) ou supérieur, car le plan Free n'inclut pas les webhooks.

## Polling ou push en quasi temps réel

La façon dont les systèmes repèrent les nouveaux abonnés constitue une ligne de partage technique majeure dans la gestion des créateurs.

| Critère d'architecture | Polling périodique | Push en quasi temps réel (`subscriptions.new`) |
| --- | --- | --- |
| **Rapidité de détection** | Dépend de votre intervalle de polling | Livraison en quasi temps réel |
| **Consommation de crédits** | 1 crédit par requête non mise en cache, à chaque polling | 1 crédit pour 100 événements webhook |
| **Déduplication** | Nécessite des registres de différences dans une base de données locale | En-tête `X-OFAPI-Idempotency-Key` pour chaque événement |
| **Infrastructure** | Boucles cron lourdes | Gestionnaire de webhooks événementiel |

En vous appuyant sur les webhooks, le message de bienvenue part en quasi temps réel après l'abonnement du fan.

## Règles des messages payants (PPV) pour les automatisations

Pour répondre à un nouvel abonné, les développeurs peuvent envoyer un texte gratuit ou joindre du contenu Pay-Per-View (PPV) verrouillé. L'API applique des règles précises à ces messages privés.

- **Contraintes de prix :** les messages privés payants sont tarifés de 3 à 200. L'API accepte un prix de 0 (gratuit) ou de 3 à 200 et rejette toute autre valeur.
- **Média obligatoire :** tout message payant dont le prix est supérieur à 0 doit contenir au moins un fichier média, sauf si `lockedText` vaut true. Un payload avec un prix, un tableau `mediaFiles` vide et sans `lockedText` renvoie une erreur de validation 422.
- **Formats d'ID de média :** le paramètre `mediaFiles` accepte les ID d'upload temporaires générés par notre API (par ex. `ofapi_media_123`) et les ID permanents de médias du coffre-fort (par ex. `3866342509`). Vous pouvez combiner ces ID dans le même tableau. Consultez notre [guide des uploads de médias](https://docs.fansapi.com/introduction/guides/uploading-media) pour savoir comment récupérer ces ID.
- **Aperçus gratuits :** pour proposer des teasers gratuits en plus des médias verrouillés, passez les ID d'aperçu dans le tableau `previews`. Chaque média listé dans le tableau `previews` doit aussi figurer dans le tableau `mediaFiles`.

## Le payload du webhook subscriptions.new

Lorsqu'un fan s'abonne, le serveur envoie un payload JSON contenant les détails de l'événement et le profil de l'abonné. Pour la liste complète des événements pris en charge et les instructions de vérification de la signature HMAC, consultez notre [guide des webhooks OnlyFans](https://fansapi.com/fr/blog/webhooks-onlyfans-abonnes-pourboires-messages).

```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
    }
  }
}
```

Le `user_id` du payload est l'ID du créateur connecté, pas celui de l'abonné. L'ID de l'abonné se trouve dans l'objet user (et fan), et il correspond généralement à son ID de chat pour les messages privés.

## Exemples de code d'implémentation

Vous pouvez écouter l'événement et déclencher un message de bienvenue avec les SDK officiels ou des requêtes REST brutes. Les webhooks sont livrés au moins une fois : les deux exemples ignorent donc les répétitions d'un même événement grâce à l'en-tête `X-OFAPI-Idempotency-Key`.

### Implémentation TypeScript 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>(); // utilisez un stockage persistant en production

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

  // Répondre d'abord, puis envoyer
  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'));
```

### Implémentation Python

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

app = FastAPI()
client = OnlyFansAPI()
seen = set()  # utilisez un stockage persistant en production

@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)
```

### Requête REST brute

```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"]
  }'
```

## Automatisation no-code des messages de bienvenue

Les créateurs et les gestionnaires d'agence peuvent construire ces séquences sans écrire de code grâce à nos [intégrations Zapier, Make et n8n](https://fansapi.com/no-code). Ces packages natifs se connectent directement à votre compte. Les déclencheurs liés aux abonnés reposent sur les webhooks : ils nécessitent donc le plan Basic ou supérieur.

- **Configuration Zapier :** sélectionnez l'app OnlyFans API et choisissez le déclencheur New Subscriber. Notre app Zapier ne propose que des déclencheurs : envoyez donc la réponse depuis n8n, Make ou votre propre code.
- **Configuration Make :** ajoutez le déclencheur OnlyFans API New Subscription. Connectez un module Make a custom API call qui envoie votre texte et un prix facultatif à l'endpoint Send Message.
- **n8n (recommandé) :** installez notre community node `@onlyfansapi/n8n-nodes-onlyfansapi`. Ajoutez un listener webhook n8n et faites pointer un webhook `subscriptions.new` vers son URL. Utilisez une logique conditionnelle pour créer des branches selon le prix d'abonnement (`{PRICE}` dans le payload), puis ajoutez le node OnlyFans API pour exécuter l'opération Send Message.