A 12-month commitment paid monthly lets your users subscribe to an annual plan while paying month by month: they commit to the full year, but instead of being charged the total price upfront, they are billed a smaller amount every month for 12 months.

This billing structure lowers the entry barrier of your annual plan (a $9.99 first charge converts better than a $119.88 one) while securing 12 months of revenue.

• On the Apple App Store, this is the monthly subscription with a 12-month commitment billing plan introduced with iOS 26.4. It requires a dedicated configuration in the Purchasely Console, detailed in the Apple App Store section below.
• On Google Play, the equivalent mechanism is installment subscriptions, which Purchasely supports out of the box: everything is configured in the Google Play Console, see the Google Play Store section below.

Apple App Store

How it works

The 12-month commitment is not a new product: it is an additional billing plan on an auto-renewable yearly subscription in App Store Connect. An eligible yearly product can therefore be sold in two ways:

With the monthly billing plan:

• Each monthly payment is an independent transaction that grants one month of access, like a regular monthly subscription.
• The user is committed to the full year: if they cancel during the commitment, the monthly billing continues until the end of the 12 periods, and they keep their access until the end of the commitment.
• At the end of the 12 payments, the commitment renews automatically for a new 12-month cycle, unless the user cancelled.
• Upgrades take effect immediately and end the commitment (standard Apple proration rules apply). Downgrades are deferred to the end of the commitment.
• The Billing Grace Period does not apply to commitments: if a monthly payment fails, access is suspended immediately and restored when the payment is recovered.

Configuring your Plan

The first step is to enable the monthly commitment billing plan on your yearly Plan in the Purchasely Console:

1. Open your Plan in the Console (its Period must be 1 year (P1Y))
2. Select the Apple application store and fill in the App Store Product id
3. Under Commitment billing type, check Monthly with 12-Month Commitment

• 1 Year Upfront is always enabled for yearly plans and cannot be unchecked.
• Monthly with 12-Month Commitment requires the matching billing plan to be enabled on the same SKU in App Store Connect.

Configuring your Screen

Once enabled on the Plan, the monthly commitment can be selected per offering in the Screen Composer:

1. Open your Screen and go to the Offering tab
2. Select the Plan for your offering
3. A Commitment billing type field appears: select Monthly with 12-Month Commitment

The Offer dropdown depends on the selected billing type: promotional offers are scoped to a billing plan, so changing the Commitment billing type resets the selected offer. Make sure your promotional offers are associated with the right billing plan when you create them.

Displaying the right prices with Tags

When an offering uses the Monthly with 12-Month Commitment billing type, the price Tags are automatically interpreted against the commitment:

Example for a plan billed $9.99 every month, i.e. $119.88 over the 12-month commitment.

For offerings using 1 Year Upfront (or any plan without a commitment), the tags keep their usual behavior described in the Tags section.

SDK behavior

The billing plan is entirely driven by the Screen configuration: the SDK purchases with the billing plan you selected in the Console, with no code change required.

If your app takes over the purchase flow (Observer mode or a custom purchase action interceptor), you need to know which billing plan the offering is selling to pass the matching purchase option to StoreKit. The action interceptor gives you all the commitment information:

• params.billingPlanType (iOS): the billing plan selected on the offering in the Screen Composer (upFront, monthly, or unspecified for a regular plan)
• plan.commitmentInfo: the billing plans available on the store product, each with its billing price, billing period, total price and number of payments

Purchasely.interceptAction(.purchase) { info, params, completion in
    guard let plan = params?.plan,
          let productId = plan.appleProductId else {
        completion(.notHandled)
        return
    }

    // Billing plan selected on the offering in the Screen Composer:
    // .upFront, .monthly, or .unspecified for a regular plan
    let billingPlanType = params?.billingPlanType ?? .unspecified

    // Billing plans available on the store product (empty below iOS 26.4)
    for commitment in plan.commitmentInfo {
        print("""
        \(commitment.billingPlanType): \
        \(commitment.billingPrice) per \(commitment.billingPeriod), \
        \(commitment.totalPrice) in total over \(commitment.totalDuration) payment(s)
        """)
        // monthly: 9.99 per P1M, 119.88 in total over 12 payment(s)
        // upFront: 119.88 per P1Y, 119.88 in total over 1 payment(s)
    }

    Task {
        do {
            guard let product = try await Product.products(for: [productId]).first else {
                completion(.failed)
                return
            }

            var options: Set<Product.PurchaseOption> = []
            if billingPlanType == .monthly, #available(iOS 26.4, *) {
                options.insert(.billingPlanType(.monthly))
            }

            let result = try await product.purchase(options: options)
            // Process the result with your own purchase infrastructure,
            // then let the SDK synchronize the transaction
            completion(.success)
        } catch {
            completion(.failed)
        }
    }
}

await Purchasely.interceptAction(
  PLYPresentationActionKind.purchase,
  (info, payload) async {
    if (payload is! PLYPurchasePayload) {
      return PLYInterceptResult.notHandled;
    }

    final storeProductId = payload.plan.productId;

    // Billing plans available on the store product
    // (Apple only, empty below iOS 26.4 and on other platforms)
    for (final commitment in payload.plan.commitmentInfo) {
      debugPrint('${commitment.billingPlanType}: '
          '${commitment.billingPrice} per ${commitment.billingPeriod}, '
          '${commitment.totalPrice} in total over ${commitment.totalDuration} payment(s)');
      // PLYBillingPlanType.monthly: 9.99 per P1M, 119.88 in total over 12 payment(s)
      // PLYBillingPlanType.upFront: 119.88 per P1Y, 119.88 in total over 1 payment(s)
    }

    final success = await MyPurchaseSystem.purchase(storeProductId);
    if (success) {
      // SDK auto-synchronizes on success in observer mode
      await info.presentation?.close();
      return PLYInterceptResult.success;
    }
    return PLYInterceptResult.failed;
  },
);

Google Play Store

On Google Play, the same mechanism is called an installment subscription: the subscriber pays a fixed amount every month over a commitment period, and the plan renews automatically at the end of the commitment.

Purchasely supports Google Play installment subscriptions out of the box, with no particular prerequisite: there is no billing type to enable on your Plan or your Screen. The whole configuration lives in the Google Play Console, where you create an installment base plan (commitment duration and renewal type) on your subscription. Purchasely then sells and tracks it like any other subscription.

To learn more about creating installment plans, check Google's documentation:

• Installment subscriptions in the Play Billing overview
• Create and manage subscriptions in the Play Console

Server events

On the backend side, each monthly installment billed to a committed subscriber generates an INSTALLMENT_PAID webhook event (12 per year for a committed subscription). Refunding a past installment generates INSTALLMENT_REFUNDED instead, without closing the subscription or ending the commitment. Events for a committed subscription also carry dedicated commitment_* attributes (installment number, commitment expiration date, auto-renewal status, and more). See Lifecycle Events and Server Events Attributes for details.