To receive server notifications from the App Store, follow the instructions in Enabling App Store Server Notifications. If your server doesn’t receive any notifications, check your server logs for any incoming web request issues, and confirm that your server supports the Transport Layer Security (TLS) 1.2 protocol or later. If you implement version 2 of App Store Server Notifications, call the Get Notification History endpoint. If there is an issue sending a notification, the endpoint returns the error the App Store received from your server. If your issue persists, submit a Feedback Assistant report with the following information: The bundleId or appAppleId of your app The date and time your issue occurred The raw HTTP body of your notification The affected transactionId(s) if applicable The version of App Store Server Notifications (i.e., Version 1 or Version 2) The environment (i.e., Production or Sandbox) To submit the report, perform these steps: Log into Feedback Assistant. Click on the Compose icon to create a new report. Select the Developer Tools & Resources topic. In the sheet that appears: Enter a title for your report. Select “App Store Server Notifications” from the “Which area are you seeing an issue with?” pop-up menu. Select “Incorrect/Unexpected Behavior” from the “What type of feedback are you reporting?” pop-up menu. Enter a description of your issue. Add the information gathered above to the sheet. Submit your report. After filing your report, please respond in your existing Developer Forums post with the Feedback Assistant ID. Use your Feedback Assistant ID to check for updates or resolutions. For more information, see Understanding feedback status.

I am using app-store-server-library-java:5.2.0. Following the official guide video, I downloaded and configured all required credentials, including the Key ID, Issuer ID, private key (.p8 file), and Bundle ID. However, when I try to send a test notification in the Sandbox environment, the request consistently returns a 401 Unauthorized error without any additional error message or details. One difference from the guide is how I handle the private key file. The guide reads the .p8 file directly from a file path on the server. In my environment, I cannot store external files on the server, so I Base64-encode the contents of the .p8 file, store it as an environment variable, and then decode it back to its original content before initializing the App Store Server API client. As far as I can tell, the decoded content matches the original key file exactly, but I am wondering whether this approach could cause any issues with authentication or JWT generation. Are there any additional prerequisites, permissions, agreements, or configuration steps that must be completed before this feature can be used? I have spent a significant amount of time troubleshooting this issue, but I have been unable to identify the root cause from the available documentation or error responses. Any guidance or suggestions would be greatly appreciated. Thank you for your help. Additional information: Library: app-store-server-library-java 5.2.0 Environment: Sandbox Credentials configured: Key ID, Issuer ID, Bundle ID, Private Key (.p8) Private key handling: Base64 encoded in environment variables, then decoded before client initialization Result: HTTP 401 Unauthorized with no response body or error details

Filed as FB24069273. Sandbox POST /inApps/v1/notifications/test consistently returns 404 {"errorCode":4040007} for our app (Apple ID 6765662617), although GET /v1/apps via the App Store Connect API confirms both subscriptionStatusUrl and subscriptionStatusUrlForSandbox are set (V2). With the same JWT, sandbox POST /inApps/v1/notifications/history returns 200 with an empty history — so the key and app resolve correctly. No organic sandbox notifications have ever been delivered, despite active TestFlight sandbox subscription activity. Exhausted remediations (4040007 persists after each, with 30-60+ minute waits): Re-saving the URLs in the App Store Connect UI (two locales) Deleting and re-adding the Sandbox URL PATCH /v1/apps setting the sandbox URL + version V2 twice, with two different valid endpoints (verified by GET each time) Removing the Sandbox URL entirely to rely on the documented Production fallback Deleting BOTH URLs, waiting a full hour, and re-creating them from scratch Testing with both an App Store Connect team key and a freshly generated In-App Purchase key — identical results Endpoints are publicly reachable (HTTPS, TLS 1.2+, port 443). Production App Store Server API returns 401, which we understand is expected for an app not yet released. This looks like a desync between App Store Connect metadata and the notification delivery registry consulted by the test-notification endpoint. Any help would be appreciated.

Environment: Production. Bundle ID: com.filmixpro.filmix. (Team ID / notification URL available privately or via Feedback Assistant.) We extended the renewal date of 3 auto-renewable subscriptions on 2026-02-28 using the Extend Subscription Renewal Date API, and received the matching RENEWAL_EXTENDED notifications. After the extended period ended, auto-renewal failed and all 3 are now in billing retry: Get All Subscription Statuses returns status=3 with expirationIntent=2 (billing error), isInBillingRetryPeriod=true, and no grace period. However, Get Notification History (production, last 180 days, filtered by transactionId) returns ONLY the RENEWAL_EXTENDED notification for each — there is no DID_FAIL_TO_RENEW (nor EXPIRED / DID_RENEW). Per the documentation, entering billing retry should produce a DID_FAIL_TO_RENEW notification. This is not a missed/undelivered webhook on our side: over the same 180-day window the global Get Notification History returned 4232 notifications and our records contain all of them, with per-type counts matching exactly (including DID_FAIL_TO_RENEW). For contrast, another subscription in the same billing-retry state (originalTransactionId 220002005208565) DID receive a DID_FAIL_TO_RENEW — so the absence is not universal, and it correlates with subscriptions extended via the API. The three affected subscriptions span three storefronts (USA / CHN / TUR), so it is not storefront-specific. Affected originalTransactionIds: 150002285191456 (extended to 2026-05-07) 320002313172683 (extended to 2026-06-05) 470002485799388 (extended to 2026-06-12) Questions: Should a subscription extended via Extend Subscription Renewal Date emit DID_FAIL_TO_RENEW when it later enters billing retry? If so, why is it absent from Get Notification History for these three while present for 220002005208565? Does extending via the API affect generation/visibility of subsequent renewal/billing notifications? How should we reconcile entitlement for subscriptions that entered billing retry without any notification?

App Store Server Notification returns successful purchase while customer's payment remains Pending We have encountered an edge case with a Non-Renewing Subscription and would appreciate clarification on the expected developer behavior. Steps to reproduce User initiates an in-app purchase using a credit card. The purchase succeeds in the app. Our backend receives an App Store Server Notification V2 (ONE_TIME_CHARGE). We successfully verify the signed JWS transaction. The same transaction is also returned by the App Store Server API. Based on the verified transaction, we grant the user's entitlement. However, on the customer's Apple account: The purchase is shown as Pending in Purchase History / Report a Problem. The customer reports that their credit card has not yet been charged. Question From a developer's perspective, should entitlement be granted immediately after receiving a valid App Store Server Notification and successfully verifying the transaction, even if the customer's purchase is still shown as Pending? Is there any App Store Server API or transaction field that indicates the payment has not yet been settled, allowing developers to delay granting entitlement until the payment is finalized? Or is the expected implementation to grant entitlement upon successful transaction verification and revoke it only if Apple later sends a refund notification? Any clarification on the expected workflow would be greatly appreciated. Thanks in advance. :)

Summary After setting a single auto-renewable subscription product (not the app) to "Developer Removed from Sale" in App Store Connect, the next scheduled renewal for an existing active subscriber failed with DID_FAIL_TO_RENEW v2 and expirationIntent = 5 ("expired for some other reason"). I expected expirationIntent = 4 ("product wasn't available for purchase at the time of renewal"), since the product was, in fact, not available for purchase. I would like to confirm whether 5 is the documented/expected value for this scenario, and how to deterministically distinguish "developer removed product from sale" from other renewal failures using the notification payload. Reproduction / observed sequence Day 15: Changed product annual_promo (auto-renewable subscription) status from "Approved" to "Developer Removed from Sale" in App Store Connect. The app itself remained Approved and on sale. Other subscription products in the same group remained Approved. Day 16: An existing active subscriber on that product had a scheduled automatic renewal date. Result: Renewal did not occur. We received a DID_FAIL_TO_RENEW v2 notification. Payload (relevant fields): JWSRenewalInfoDecodedPayload.expirationIntent = 5 JWSRenewalInfoDecodedPayload.autoRenewStatus = 0 Questions Is expirationIntent = 5 the correct/expected value when a renewal fails because the developer removed the product from sale? Or should it have been 4 ("product wasn't available for purchase at the time of renewal")? If 5 is intentional, what is the engineering rationale for not using 4 in this scenario? Given that expirationIntent = 5 is documented as a catch-all ("some other reason"), which other fields in the DID_FAIL_TO_RENEW payload (e.g., subtype, autoRenewStatus, gracePeriodExpiresDate, signedTransactionInfo) should we inspect to deterministically classify the failure cause and isolate "developer removed product from sale" from billing failure / customer cancel / price-increase not accepted / etc.? Context I'm aware of the docs page In-App Purchase statuses and Set availability for an auto-renewable subscription, but they describe the status semantics, not the resulting notification payload. Product has been reverted to "Approved" to avoid further impact on subscribers while this is clarified. Thanks in advance.

Does TestFlight's sandbox resolves storefront differently from production — because if it does, my production launch will be unaffected and this is a testing artefact. Right now, the storefront always resolves as US and fetches USD pricing, even though in my AppStoreConnect, availability and pricing country is restricted to India alone, and ideally the fetch to my subscription page shoul dbe in Indian Rupee. Any observations, any one please?

Am same facing Storekit issue 0 product returns in Product identifier Array. Even i test on device it returns invalid product identifier due to 0 product array. Issue Description Step 1 Create a new Auto-Renewable Subscription from the App Information page in App Store Connect. Step 2 Complete all the required fields for the Auto-Renewable Subscription and click the "Save" button. Expected Result After saving, the subscription status should change from "Prepare for Submission" to "Ready to Submit". Actual Result The subscription status remains "Prepare for Submission" and does not change to "Ready to Submit", even though all required information has been completed and the subscription has been saved. I am currently facing a critical issue while creating an Auto-Renewable Subscription in "App Store Connect". I have already completed all the required subscription details. However, whenever I click the "Save" button, the subscription status does not change from "Prepare for Submission" to "Ready to Submit", as expected. Because the subscription never reaches the "Ready to Submit" state, every purchase attempt in the Sandbox environment fails with the following error: SKErrorDomain Code = 3 "Invalid Product Identifier" To troubleshoot the issue, I have already: Created multiple new Product Identifiers, but every identifier is reported as "invalid" in the Sandbox environment. Verified that my "Banking, Tax, and Paid Applications Agreement" is complete and active. Confirmed that all required fields for the Auto-Renewable Subscription have been filled in before saving. Since I am unable to submit the subscription for review and all Product Identifiers remain invalid, I believe there may be an issue with my App Store Connect configuration or account. I would appreciate it if you could investigate this issue and help resolve it as soon as possible, as it is currently blocking the implementation and testing of in-app purchases.

Hello, I’m experiencing an issue with App Store Server Notifications Version 2 in the sandbox environment. Initially, an old sandbox callback URL was configured. I then replaced it with a new callback URL in App Store Connect. The new URL was saved successfully, but newly created sandbox TEST notifications continued to be sent to the old URL. To investigate further, I removed both the production and sandbox callback URLs completely. App Store Connect showed both fields as empty, and the App Store Connect API returned null for the corresponding URL attributes. However, newly created sandbox TEST notifications were still sent to the same old URL. I later used the “Modify an App” API to configure the new production and sandbox callback URLs. The PATCH request returned HTTP 200, and a subsequent GET request confirmed the new URLs and Version 2 settings. Despite this, new sandbox TEST notifications continued to use the old hostname in the HTTP Host header. I confirmed that these are new notifications, not retries: Every test returns a new testNotificationToken. The notificationUUID matches the UUID in that new testNotificationToken. The new callback URL is publicly accessible over HTTPS. The new URL returns HTTP 200 and doesn’t redirect to the old URL. The behavior is therefore: Configure a new URL → notifications still go to the old URL. Remove all configured URLs → notifications still go to the old URL. Update the URLs through the App Store Connect API → notifications still go to the old URL. It appears that the notification delivery service is using a stale callback configuration that isn’t synchronized with App Store Connect. Is there a separate cache or routing configuration for App Store Server Notifications? Is there a way to force the effective callback URL to refresh? Thank you.

Environment: Production. Bundle ID: com.filmixpro.filmix. (Team ID / notification URL available privately or via Feedback Assistant.) We received 7 App Store Server Notifications V2 (SUBSCRIBED) whose JWS signatures we successfully verified against Apple root CAs (decoded payloads show environment=Production, bundleId=com.filmixpro.filmix). However, querying the App Store Server API (production) for these originalTransactionIds returns 404 (4040010) "Transaction id not found" on EVERY endpoint: Get All Subscription Statuses, Get Transaction Info, Get Transaction History, Get Refund History, and Get Notification History (filtered by transactionId). The same API key resolves all other transactions correctly (these are 7 out of 3231 chains scanned). The IDs are also absent from the global Get Notification History (last 180 days). Sandbox returns 404 as well. One of them, 520002039865757, previously generated a REFUND_DECLINED notification (a refund was requested and DECLINED — i.e. not refunded), yet it too now returns 404 on every endpoint including Get Refund History, so the disappearance is not explained by a refund. Affected originalTransactionIds: 590002039736765, 590002053449909, 430002231597484, 70003114793852, 100002338147592, 520002039865757, 340001586213801 Questions: Why do Apple-signed, Production transactions return 404 "Transaction id not found" on all App Store Server API endpoints? Have these transactions been removed/invalidated (fraud, chargeback, account deletion, refund reversal)? If so, which category? We recently signed a previously-unsigned Paid Applications Agreement — does this affect API visibility of historical transactions, and what is the propagation time? How should we reconcile entitlement for transactions that were signed/notified but are not found in the Server API?

I’m experiencing an issue with Apple Developer Support communication. On the page Apple Developer Support Cases I can see updates and messages indicating that Apple Support specialists supposedly replied to my case. However, I never receive those emails in my inbox. The only emails that actually arrive to my Gmail account are automatic messages with the subject: “Thanks for submitting your support request” I checked: Spam folder Promotions/Social tabs Gmail filters Blocked addresses But there are still no replies from support specialists. Because of this, I cannot continue communication with support. Has anyone experienced the same issue? Is there a specific Apple domain/email address that should be whitelisted? Apple Support team, please contact me directly.

Our app offers auto-renewable subscriptions using StoreKit Original API for In-App Purchase and App Store Server Notifications V1. Starting around 2025-03-15, we found some cases where original_transaction_id which was associated to web_order_line_item_id of already purchased subscription had changed in the receipt information of verifyReceipt response or App Store Server Notifications V1. The detailed steps are: Around February 2025, re-purchase from the app the same subscription product which was canceled and expired some time ago, using StoreKit Original API for In-App Purchase Receive the following 2 notifications from App Store Server Notifications V1 almost at the same time INITIAL_BUY DID_CHANGE_RENEWAL_STATUS In both notifications, latest_receipt_info contains the receipt for the re-purchased subscription period with new original_transaction_id and web_order_line_item_id pending_renewal_info contains both new original_transaction_id and original one which was generated at first purchase, and original one has "is_in_billing_retry_period": "1" Starting around 2025-03-15, the following happens When we receive another "DID_CHANGE_RENEWAL_STATUS" notification from App Store Server Notifications V1, original_transaction_id which is associated to web_order_line_item_id of the re-purchased subscription period has changed back to the original one (the one which was generated at first purchase) in latest_receipt_info. When we call verifyReceipt with the receipt obtained from appStoreReceiptURL, the response does not seem to contain new original_transaction_id which was generated at re-purchase We have some questions regarding this original_transaction_id behavior. When a user re-purchase the same subscription product which was canceled and expired some time ago, it seems that new original_transaction_id is generated. Is this an expected behavior? If yes, it seems that, at some point, original_transaction_id which is associated to web_order_line_item_id of the re-purchased subscription changed back to the original original_transaction_id which had been generated at first purchase. Is this an expected behavior? What triggers the original_transaction_id change to the original one? Is it related to some user actions or subscription status change?

Context We're handling App Store subscriptions on the server side using App Store Server Notification v2. Our pipeline currently identifies each event by transactionId and originalTransactionId. A few notes about our client: Our app is built with Flutter and uses the standard in_app_purchase plugin layer to drive App Store purchases (StoreKit 1 under the hood). We have not migrated to StoreKit 2 on the client yet. We have not been setting SKPayment.applicationUsername on outgoing purchases, so every transaction we've ever produced has appAccountToken: null in its v2 notification. This question is purely about what the server-side notification can tell us, given the current client state above. What we're trying to figure out A user can resubscribe to an expired subscription in two different places: In-app — the user opens our app and re-purchases through our normal in-app purchase flow. App Store — the user goes to Settings → Apple ID → Subscriptions and resubscribes from the system UI, without ever returning to the app. Both paths trigger a SUBSCRIBED notification (subtype RESUBSCRIBE) with structurally identical payloads as far as we can tell — same shape for data.transactionInfo, data.renewalInfo, etc. From the notification alone we can't decide which path produced it. The reason this matters: in our system, the two paths require different business handling: In-app path: the user may have signed in to a different business account in our app. The new subscription should be attributed to whoever paid in the app just now, not to the previous owner of originalTransactionId. App Store path: there is no in-app signal, so the business owner can only be inferred from the previous originalTransactionId mapping. If we get it wrong, the subscription's entitlement ends up on the wrong business account. What we do today Because we can't tell the paths apart from the notification, we defer processing for a few minutes and check whether an in-app order for the same transaction has arrived in the meantime: If an in-app order shows up → it's the in-app path; attribute to the in-app account. If nothing shows up after the delay → assume App Store path; fall back to the previous owner mapping. This works but adds latency to entitlement activation and forces us to build a deferred-retry queue with idempotency against the in-app callback path. Possible direction: appAccountToken / applicationUsername We noticed that v2 notifications carry transactionInfo.appAccountToken, and the docs suggest that StoreKit 1's SKPayment.applicationUsername (when it's a valid UUID) is mirrored into this field. In theory, if we start setting it on every in-app purchase from the Flutter client, the field could double as a path discriminator on the server: appAccountToken != null → in-app path (only the app can set it), and we even get the business user id for free appAccountToken == null → App Store path (no UI to populate it) But we have some open questions before committing to this direction: Questions Is there an existing signal in ResponseBodyV2 / JWSTransactionDecodedPayload / JWSRenewalInfoDecodedPayload that distinguishes these two paths, that I might be missing? Can the same distinction be obtained via getAllSubscriptionStatuses / getTransactionHistory / any other Server API endpoint? Is applicationUsername (StoreKit 1) still a reliable way to populate appAccountToken on v2 notifications today? Specifically: Are there format constraints beyond "valid UUID" that cause Apple to drop the value? Any known differences between sandbox and production in how it's mirrored? Does the App Store path ever strip or overwrite a previously-set value when the same originalTransactionId is reused? For existing subscriptions where applicationUsername was never set (which is all of ours today, since we've never polient), is there any way to retroactively distinguish the in-app vs App Store path? Or is timing-based deferred matching theonly option for that cohort, even after we start setting the value on new purchases? If neither (1) nor (2) is currently possible, is the timing-based heuristic we use today the pattern Apple expects developers to follow, or is there a recommended approach we're missing? A small suggestion, if it turns out there's no existing way If the information genuinely isn't exposed today, it might be worth surfacing a salesChannel-style field on the transaction, similar to what Google Play Developer API exposes on Order.salesChannel (IN_APP, PLAY_STORE, etc.). That would let server-side handlers route each event to the correct business owner immediately, regardless of whether appAccountToken was set, and would also cover legacynt never had a chance to populate it. Thanks — happy to share sample payloads or more detail if helpful.

Hello, We are planning to shut down our mobile app service and need to discontinue our auto-renewable subscription product. Our service termination date is July 31, and we are currently preparing the backend implementation for this. We have reviewed the official documentation and Apple Developer Forums, but there are several behaviors we cannot confirm through sandbox testing, as the "Remove from Sale" setting does not appear to affect the sandbox environment. We would greatly appreciate clarification on the following: Server notification at the moment of "Cleared for Sale" being unchecked When we uncheck "Cleared for Sale" in App Store Connect, is any App Store Server Notification (V2) sent to our server immediately at that moment? If yes, what is the exact notificationType and subtype value sent? If no, when is the first notification triggered for existing active subscribers after this action? 2. Notification sequence from product removal through final expiration For existing active subscribers, what is the exact sequence of notificationType and subtype values our server should expect — from the moment we remove the product from sale through the subscriber's final expiration? Based on our research, we believe the sequence may be: (1) Cleared for Sale unchecked → (2) No immediate notification → (3) At next renewal attempt → EXPIRED with subtype PRODUCT_NOT_FOR_SALE Could you confirm whether this is correct, or provide the accurate sequence? 3. Whether DID_CHANGE_RENEWAL_STATUS is sent before EXPIRED Is a DID_CHANGE_RENEWAL_STATUS notification sent to our server at the moment of removal from sale, before the EXPIRED notification at the renewal date? If yes, what is the subtype of this notification? 4. Recommended server-side handling per notification For each notification in the sequence above, what is the recommended server-side action? For example: On EXPIRED with subtype PRODUCT_NOT_FOR_SALE → revoke entitlement immediately? On DID_CHANGE_RENEWAL_STATUS (if sent) → update status only, do not revoke entitlement yet? Sandbox testing limitations We have confirmed that the "Remove from Sale" setting does not affect the sandbox environment. Is there any recommended way to test this scenario before applying it in production? If sandbox testing is not possible for this case, is there any official confirmation of this limitation? We have a fixed service termination schedule and need to ensure our backend handles this correctly. Any clarification or pointers to official documentation would be greatly appreciated. Thank you.

Hey We have noticed a change in the retry behavior of Apple Server Notifications webhooks V2 starting around March 12–13, 2026. Previously, when our webhook endpoint returned an HTTP 400 response, Apple would retry the notification delivery multiple times according to the documented retry policy. However, beginning around March 12–13, it appears that Apple no longer retries the webhook when a 400 response is returned. The notification is sent only once and no further retry attempts are made. From our understanding of the documentation, retries should occur when delivery fails, and historically we observed retries even for some 4xx responses. We would like to confirm: Has Apple recently changed the retry behavior for Server Notifications? Are HTTP 4xx responses (specifically 400) now considered terminal failures that will not trigger retries? Is this change intentional or related to a rollout in the webhook delivery system? We have called the "Notification History" endpoint for some users who purchased a sub and we are only getting one attempt with the following data in it: { attemptDate: 1773469202552, (2026-03-14T06:20:02.552Z) sendAttemptResult: 'UNSUCCESSFUL_HTTP_RESPONSE_CODE', } This was 2 days ago, based on the docs, the user should have a few attempts at least. This behavior change affects systems that rely on retries to handle temporary validation issues or transient failures. Thanks!

Hi, I’ve been invited to an Apple Developer account with the Developer role. I’ve already created a subscription in App Store Connect, but when I try to fetch available subscriptions in Xcode for in-app purchase, nothing appears to be available for purchase.

Hi all, I'm encountering an issue with auto-renewable subscription upgrades in the App Store. Here's my setup: Context: Plan A: Base Plan (yearly auto-renewable subscription) Plan B: Pro Plan (monthly auto-renewable subscription) B is configured as an upgrade from A. Issue: When a user with an active Plan A subscription upgrades to Plan B, I correctly receive an App Store Server Notification v2 with DID_CHANGE_RENEWAL_PREF and UPGRADE subtype. According to Apple's documentation, a prorated refund is issued automatically in this scenario, and no separate REFUND event is sent, the refund information should be retrievable through the upgrade event itself. Testing in Sandbox: In my sandbox tests, Plan A has a 1-hour duration and Plan B has a 5-minute duration. After the user upgrades to Plan B, I immediately cancel the subscription to prevent auto-renewal. Expected vs. Actual Behavior: After the 5 minutes expire, Plan A still appears as the active current entitlement. I initially thought this might be because the prorated refund hadn't been processed yet. However, even after waiting the full hour (the original duration of Plan A), it continues to show as an active entitlement—which shouldn't be the case. As a result, when I attempt to restore purchases, Plan A is still identified as valid and the subscription gets reactivated. Question: Is this behavior expected in the sandbox environment, or am I missing something in how the prorated refund and entitlement expiration should be handled?

Based on https://developer.apple.com/help/app-store-connect/configure-in-app-purchase-settings/enter-server-urls-for-app-store-server-notifications It seems like we can choose between version 1 or version 2 notification Choose either Version 1 (deprecated) or Version 2 notifications. Learn about versions of App Store Server Notifications. However, I do not find a way to make such a choice. Does anyone know, how I can choose between v1 or v2 notification? We currently provide a self-hosted server endpoint built on the v1 specification. While the existing server is perfectly stable, we are evaluating a migration to v2. Thanks.

We are developing a platform (Ferve) where users subscribe to individual artists to access exclusive content. We use a user-centric remuneration model: each artist has an independent income pool, and funds from a specific subscription must be attributed solely to that artist. We have two critical challenges regarding our integration: Granular Financial Reporting for User-Centric Payouts As the Merchant of Record, Apple provides aggregate Financial Reports. However, these reports do not provide a breakdown of taxes, commissions, or exact exchange rates used for individual transactionId records. Though we can keep records of each transaction in our database, thus linking them with which artist they belong to, we are unable to collect fees/taxes applied to each individual transaction. Because our payouts are artist-specific, we need to deduct the exact regional taxes and Apple commissions from each transaction to calculate the artist's due balance. Currently, we can only see the final consolidated balance in BRL (Brazilian Reals) at the end of the month. Is there an API or report that provides the net proceeds and tax breakdown per transaction ID? How can we retrieve the exact exchange rate applied to foreign currency sales (e.g., EUR to BRL) before the final consolidation? Supporting Multiple Concurrent Subscriptions Our current App Store Connect configuration uses a single 'Subscription Group' for all artist 'Clubs' since they share the same price points. However, we have found that users cannot subscribe to more than one product within the same group simultaneously (the App Store treats this as an upgrade/downgrade). On our platform, a user must be able to subscribe to Artist A and Artist B at the same time. What is the recommended architecture for this? Should we dynamically create a unique Subscription Group for every artist onboarded to our platform? If we use unique groups, is there a limit to the number of Subscription Groups one app can have? We appreciate the help, Ferve

I am contacting you to clarify a technical issue regarding the behavior of App Store Server Notifications (V2), as we have observed differences depending on the subscription plan. Currently, we have noticed the following behavior when a refund occurs for an auto-renewable subscription: Observed Behavior: Monthly Plan:When a refund occurs, we receive a REFUND notification, followed by an EXPIRED notification indicating the subscription has ended. Annual Plan:When a refund occurs, we receive the REFUND notification, but the expected EXPIRED notification does not arrive. Questions: Are there any differences in the conditions for sending EXPIRED notifications after a REFUND, depending on the subscription plan (monthly vs. annual)? Is the absence of the EXPIRED notification for annual plans an intended behavior by Apple, or could it be a possible issue? I would appreciate your guidance on this matter.

Hello, We are experiencing an issue related to Sign in with Apple Server-to-Server (S2S) notifications, specifically involving repeated delivery of the account-deleted event, and would like to ask whether this behavior is expected or known. Background We have configured an S2S notification endpoint for Sign in with Apple in accordance with Apple’s requirements for account status change notifications. Our endpoint: Is reachable over HTTPS Consistently returns HTTP 200 OK Successfully receives other S2S events, including: email-enabled email-disabled consent-revoked Issue: Repeated 'account-deleted' events for the same Apple ID For most users, the account-deleted event is delivered only once, as expected. However, for a specific Apple ID used with Sign in with Apple, we are observing repeated deliveries of the same account-deleted event, arriving at regular intervals (approximately every 5 minutes). The payload contents are identical between deliveries and include the same user identifier (sub) and event timestamp. Notably: The Apple ID deletion itself completed successfully The payload does not change between deliveries Our endpoint continues to return HTTP 200 OK for every request Questions We would appreciate clarification on the following points: Is repeated delivery of the same account-deleted event expected behavior in any scenario? Is there a retry or redelivery mechanism for this event type, even when HTTP 200 is returned? Could repeated deliveries indicate that the deletion process is still considered “in progress” on Apple’s side? Are developers expected to treat account-deleted events as at-least-once delivery and handle them idempotently? Additional context While researching this issue, we found a forum thread describing a very similar case: https://developer.apple.com/forums/thread/735674 In that discussion, Apple staff advised submitting the issue via Feedback Assistant, which suggests that this behavior may already be understood internally. We have also submitted a Feedback Assistant report with detailed logs and timestamps. Any clarification on the expected behavior or recommended handling for this scenario would be greatly appreciated. Thank you for your time and support.