# Suivi des abonnements de l'App Store

<Aside type="caution" icon="setting" title="Assistance d'un développeur requise">
Vous aurez besoin de l'aide de votre équipe de développement pour configurer cette intégration. Veuillez partager ce guide avec eux.
</Aside>

## Aperçu de l'intégration

Les [notifications serveur de l'App Store](https://developer.apple.com/documentation/appstoreservernotifications) sont le service de serveur à serveur d'Apple qui envoie à votre backend un message en temps réel chaque fois que le statut d'un abonnement change.

En connectant les notifications serveur de l'App Store à Pushwoosh, vous pouvez réagir à l'ensemble du cycle de vie de l'abonnement, y compris les achats, les renouvellements, les annulations, les problèmes de facturation, les expirations et les remboursements, sans avoir à construire votre propre infrastructure backend. Chaque fois que le statut d'un abonnement change dans le compte App Store d'un utilisateur, Apple en informe Pushwoosh, et Pushwoosh déclenche l'événement [`PW_Subscription*`](#tracked-events) correspondant sur le profil de l'utilisateur.

<Aside type="note">
Cette intégration prend en charge les **abonnements iOS** (notifications serveur de l'App Store V2). Pour suivre les abonnements Android, consultez le [suivi des abonnements Google Play](/fr/product/integrations/google-play-subscription-tracking/).
</Aside>

### Type d'intégration

**Source :** les notifications serveur de l'App Store sont envoyées d'Apple à Pushwoosh.

### Événements suivis

Pushwoosh mappe chaque notification de l'App Store prise en charge à un ensemble d'événements unifié `PW_Subscription*`, afin que vous puissiez déclencher des campagnes à n'importe quelle étape du cycle de vie de l'abonnement.

| Événement | Se déclenche lorsque |
| ----- | ---------- |
| `PW_SubscriptionStart` | Un utilisateur achète l'abonnement pour la première fois. |
| `PW_SubscriptionRenew` | L'abonnement se renouvelle automatiquement pour une nouvelle période de facturation. |
| `PW_SubscriptionCancel` | Un utilisateur désactive le renouvellement automatique. L'abonnement reste actif jusqu'à son expiration. |
| `PW_SubscriptionResume` | Un utilisateur réactive le renouvellement automatique ou se réabonne avant l'expiration de l'abonnement. |
| `PW_SubscriptionBillingIssue` | Un paiement de renouvellement échoue et l'abonnement entre dans la période de nouvelle tentative de facturation d'Apple. |
| `PW_SubscriptionRecovered` | Un renouvellement qui avait précédemment échoué est accepté et l'abonnement est de nouveau actif. |
| `PW_SubscriptionExpired` | L'abonnement a complètement expiré et n'est plus actif. |
| `PW_SubscriptionRefund` | Apple rembourse l'achat ou révoque l'accès. |

Chaque événement comporte les mêmes attributs :

- **productID :** l'identifiant de produit de l'App Store de l'abonnement.
- **expiresAt :** la date de fin de la période payée en cours, sous forme d'horodatage Unix en secondes. Inclus lorsque Apple le fournit.

<details>

<summary>Comment les événements sont mappés aux notifications serveur de l'App Store</summary>

Pour les développeurs qui vérifient l'intégration, chaque événement Pushwoosh correspond à ces valeurs `notificationType` (et `subtype`) de l'App Store :

| Événement Pushwoosh | `notificationType` / `subtype` |
| --------------- | ------------------------------ |
| `PW_SubscriptionStart` | `SUBSCRIBED` / `INITIAL_BUY` |
| `PW_SubscriptionRenew` | `DID_RENEW` |
| `PW_SubscriptionCancel` | `DID_CHANGE_RENEWAL_STATUS` / `AUTO_RENEW_DISABLED` |
| `PW_SubscriptionResume` | `DID_CHANGE_RENEWAL_STATUS` / `AUTO_RENEW_ENABLED`, `SUBSCRIBED` / `RESUBSCRIBE` |
| `PW_SubscriptionBillingIssue` | `DID_FAIL_TO_RENEW` |
| `PW_SubscriptionRecovered` | `DID_RENEW` / `BILLING_RECOVERY` |
| `PW_SubscriptionExpired` | `EXPIRED` |
| `PW_SubscriptionRefund` | `REFUND`, `REVOKE` |

Les autres types de notifications, tels que les augmentations de prix, les changements de forfait, les mises en attente et les demandes de consommation, sont reconnus mais ne publient pas d'événement.

</details>


### Comment ça marche

1. Le statut d'un abonnement change dans le compte App Store d'un utilisateur (un achat, un renouvellement, une annulation, etc.).
2. Apple envoie une notification serveur de l'App Store (V2) à votre URL de notification Pushwoosh.
3. Pushwoosh décode la charge utile signée et lit le `appAccountToken` de la transaction.
4. Pushwoosh recherche l'appareil dont le HWID correspond à ce jeton, trouve l'utilisateur qui y est lié et publie l'événement `PW_Subscription*` correspondant pour cet utilisateur.

<Aside type="caution" title="Important">
La correspondance entre une transaction de l'App Store et un utilisateur Pushwoosh repose sur le `appAccountToken`. Si votre application ne définit pas ce jeton au moment de l'achat, Pushwoosh reçoit la notification mais **aucun événement n'est publié**. Voir [comment définir `appAccountToken`](#set-appaccounttoken-to-the-devices-pushwoosh-hwid).
</Aside>

### Cas d'utilisation

**Reconquérir les abonnés qui se désengagent :** la désactivation du renouvellement automatique ne met pas fin à l'accès immédiatement. L'abonnement reste actif jusqu'à la fin de la période payée, et c'est votre fenêtre d'opportunité pour reconquérir l'utilisateur. Sur `PW_SubscriptionCancel`, lancez un [Customer Journey](/fr/product/customer-journey/pushwoosh-journey-overview/) avec un push de rétention, un [e-mail](/fr/product/messaging-channels/emails/) sur les fonctionnalités qu'ils perdraient, ou un [message in-app](/fr/product/messaging-channels/in-apps/) avec une réduction sur le renouvellement avant que l'accès n'expire.

**Intégrer les nouveaux abonnés :** déclenchez une série de bienvenue sur `PW_SubscriptionStart` pour aider les utilisateurs à tirer profit de leur forfait dès le début et préparer le terrain pour le renouvellement.

**Sauver les paiements échoués :** lorsque `PW_SubscriptionBillingIssue` se déclenche, un paiement de renouvellement n'a pas abouti et l'abonnement est dans la fenêtre de nouvelle tentative d'Apple. Invitez l'utilisateur à mettre à jour son mode de paiement avant de perdre l'accès, et faites un suivi avec `PW_SubscriptionRecovered` pour confirmer une fois le problème résolu.

**Réengager les utilisateurs inactifs :** lancez une campagne de réactivation sur `PW_SubscriptionExpired` avec une offre de retour pour les abonnés qui se sont complètement désabonnés.


## Configuration de l'intégration

### Définir `appAccountToken` sur le HWID Pushwoosh de l'appareil

Pushwoosh identifie le bon utilisateur à partir du **HWID** de l'appareil, votre application doit donc joindre le HWID Pushwoosh de l'appareil en tant que `appAccountToken` lorsque l'abonnement est acheté via StoreKit.

Par défaut, le SDK iOS de Pushwoosh utilise l'`identifierForVendor` (IDFV) de l'appareil comme HWID. L'IDFV est déjà un `UUID`, exactement le format requis par Apple pour `appAccountToken`. Pushwoosh résout ensuite automatiquement l'utilisateur actuellement lié à cet appareil, cela fonctionne donc que vous attribuiez ou non vos propres ID utilisateur avec `setUserId`.

<Tabs>
<TabItem label="StoreKit 2">
```swift
// Attach the device's Pushwoosh HWID (the default IDFV) as the appAccountToken
var options: Set<Product.PurchaseOption> = []
if let hwid = UIDevice.current.identifierForVendor {
    options.insert(.appAccountToken(hwid))
}

let result = try await product.purchase(options: options)
```
</TabItem>
<TabItem label="StoreKit 1">
```swift
// applicationUsername must be a UUID string to populate appAccountToken
let payment = SKMutablePayment(product: product)
payment.applicationUsername = UIDevice.current.identifierForVendor?.uuidString
SKPaymentQueue.default().add(payment)
```
</TabItem>
</Tabs>

<Aside type="caution">
Si votre application remplace le HWID de Pushwoosh (par exemple, via le module HWID persistant [`PushwooshKeychain`](/fr/developer/pushwoosh-sdk/ios-sdk/ios-keychain/) ou une valeur personnalisée), définissez `appAccountToken` sur ce même HWID. Le jeton doit correspondre au HWID de l'appareil dans Pushwoosh, sinon l'événement ne peut pas être attribué.
</Aside>

### Trouver votre code d'application Pushwoosh

Ouvrez votre application dans le panneau de contrôle Pushwoosh. Votre **code d'application** (format `XXXXX-XXXXX`) est affiché sous le nom du projet dans la barre latérale.

Vous aurez besoin du code d'application pour construire l'URL de notification.

### Ajouter l'URL de notification dans App Store Connect

1. Dans [App Store Connect](https://appstoreconnect.apple.com/), allez dans **Apps → votre app → App Information** (sous *General*), et faites défiler jusqu'à **App Store Server Notifications**.
2. Sélectionnez les notifications de la **Version 2**.
3. Définissez à la fois l'**URL du serveur de production** et l'**URL du serveur de bac à sable** sur :

```
https://appstore-notifications.pushwoosh.com/appstore/YOUR_APPLICATION_CODE/
```

4. Remplacez `YOUR_APPLICATION_CODE` par le code d'application de l'étape précédente. Conservez la barre oblique finale.

<Aside type="note">
Si votre compte est hébergé dans le **centre de données américain**, utilisez plutôt `https://appstore-notifications.pushwoosh.us/appstore/YOUR_APPLICATION_CODE/`. Si vous n'êtes pas sûr du centre de données utilisé par votre compte, contactez votre Customer Success Manager ou le [Support Pushwoosh](https://www.pushwoosh.com/contact-us/).
</Aside>

### Confirmer les événements dans Pushwoosh

Pushwoosh enregistre chaque événement `PW_Subscription*` dans votre projet la première fois qu'il se produit, avec les attributs `productID` et `expiresAt`. Après un test en bac à sable, ouvrez **Audience → Events** pour vérifier que les événements apparaissent. Ils sont alors prêts pour la segmentation, les statistiques et les Customer Journeys.

### Construire votre campagne

Créez un [Customer Journey](/fr/product/customer-journey/pushwoosh-journey-overview/) avec une [entrée basée sur un déclencheur](/fr/product/customer-journey/journey-elements/entry-elements/trigger-based-entry/) sur n'importe quel événement `PW_Subscription*`, par exemple `PW_SubscriptionCancel` pour la reconquête ou `PW_SubscriptionStart` pour l'intégration, et ajoutez les messages que vous souhaitez envoyer.

## Test

Les notifications serveur de l'App Store peuvent être déclenchées dans l'environnement **Sandbox** d'Apple. Pour vérifier l'intégration :

1. Effectuez un achat d'abonnement en bac à sable avec `appAccountToken` défini comme décrit ci-dessus. Cela déclenche `PW_SubscriptionStart`.
2. Désactivez le renouvellement automatique depuis l'écran de gestion des abonnements de l'appareil. Cela déclenche `PW_SubscriptionCancel`.
3. Dans le panneau de contrôle de Pushwoosh, ouvrez le profil de l'utilisateur et allez dans l'[historique des événements](/fr/product/audience-data-and-segmentation/user-explorer/#events-history-tab).
4. Confirmez que les événements apparaissent en quelques instants.