In this article
Support refunds a subscription payment. The customer assumes the subscription has ended, but the next renewal still happens. In another account, a partial goodwill refund removes every paid feature even though the customer was meant to keep using the service.
Both failures come from treating several decisions as one event. A refund changes money associated with a payment. Cancellation changes the subscription’s continuation. Revocation changes access. Some purchase-channel operations combine these actions, but your product still needs to understand the result of each one.
Keep money, renewal and access in separate fields
For a fictional subscription paid at $120, a $30 partial refund leaves $90 of collected cash before fees. A total refund of $120 leaves zero. Neither calculation tells you when the customer should lose a capability or whether another payment will be attempted.
Stripe’s refund documentation supports full and partial refunds and distinguishes states such as pending and failed. A refund request is therefore also different from a completed refund. Keep that state visible to the people handling the customer request.
A useful account record has separate answers to these questions:
- What payment was collected, and how much has been successfully refunded?
- Is renewal still enabled, and when does the subscription end?
- Which capabilities are currently available, and until when?
- What action did the customer request, and which action did the operator authorize?
The last question protects against a surprisingly ordinary mistake: selecting the right monetary amount for the wrong purchase or the wrong subscription. A customer may have several purchases, several products or more than one workspace.
Write the state table before building the support button
The following table describes decisions for a fictional directly billed product. It is not a universal default for payment providers or app stores. Any chosen policy must fit the actual offer and applicable purchase-channel requirements.
| Requested action | Money decision | Renewal decision | Access decision |
|---|---|---|---|
| Partial goodwill refund | Return the approved part of a specific payment | Leave unchanged unless separately requested | Keep the agreed service available |
| Full refund only | Return the approved payment in full | Must be explicitly chosen | Must be explicitly chosen |
| Cancel at period end | No refund implied | Stop future renewal at the specified boundary | Continue eligible access through the stated end |
| End service immediately and refund | Determine the approved refund amount | End the relevant subscription now | Remove the affected access at the effective time |
For this fictional business, a partial service problem could produce a $30 refund while the subscription continues. A request to undo the purchase might instead produce a full refund plus immediate cancellation and access removal. Those are two different authorized operations, even when the same support screen performs them.
Avoid a button labeled simply “Refund and close” if “close” might mean the ticket, the subscription or the customer’s entire account. Show the resulting amount, renewal state and access end time before the operator commits the change.
Decide the effective time for each action
Stripe documents immediate cancellation and cancellation at period end. A scheduled period-end cancellation allows the current paid period to finish. That makes the effective time part of the product behavior, not an incidental timestamp in a billing dashboard.
When access continues to period end, display that end clearly. A canceled-renewal label beside a locked feature is confusing if the customer still has time remaining. Conversely, an immediate end should not leave the application promising another month of service because it displays an old renewal date.
Refund timing can differ from access timing. If a refund is pending, the product should describe it as pending. Decide whether the agreed access change takes effect immediately or waits for another event, then implement that policy consistently. Do not let a transient refund state choose the policy accidentally.
A failed refund also needs an owner. Restoring paid access automatically may not resolve a request to end service, while leaving the refund failure invisible leaves the customer without the expected money. Route the exception to a clear operational queue with the original decision preserved.
Respect purchase-channel behavior
Store-managed subscriptions can couple actions differently from direct web billing. Google Play’s subscription lifecycle distinguishes cancellation with remaining entitlement from revocation. For a cancellation, the current expiry determines whether access remains; a revocation requires immediate removal of the affected entitlement.
Google’s subscriptionsv2.revoke operation specifies a refund type as part of revoking the purchase. Treat that as a channel-specific combined operation. It is not evidence that every refund on every platform has the same access consequence.
Keep separate handling for each supported purchase channel. An internal support action should identify the original channel and use its supported operation, then reconcile the resulting state. A generic “refunded” event name can hide meaningful differences between a partial payment adjustment and a store revocation.
Do not grant a conflicting entitlement merely to make an internal table look consistent. If the channel says access has ended, the application must reflect the authoritative state for that purchase. A separate goodwill grant, where appropriate and permitted, should have its own reason and expiry rather than rewriting the purchase history.
Reconcile the whole subscription, not only the last event
Events can arrive after the operator’s screen has changed. A customer might have another active purchase that grants the same capability. Removing a feature solely because one old payment was refunded could therefore remove access the customer still holds through a different valid purchase.
Resolve the current entitlement from the relevant active grants and purchase states. Keep the payment identifier, subscription identifier and affected capability connected, so an event cannot revoke access across an unrelated workspace or product.
Record operations idempotently: repeating the same request should not create a second refund or apply a second destructive transition. If a later event contradicts the local state, retrieve the current provider record and investigate the discrepancy before assuming the most recently delivered message is the most recent business action.
Support should be able to see the authorized request, the provider response, the effective subscription state and the access update. A ticket marked resolved is not proof that all four completed.
Make the confirmation match the result
A useful confirmation says how much was refunded, whether that refund is complete or pending, whether renewal is stopped, and when access ends. If one action failed while another succeeded, explain the partial result and the next step.
Test a partial refund with continued service, a full refund paired with immediate termination, a period-end cancellation without refund, and a failed refund after access has changed. Include repeated operator submissions and a customer with another valid subscription to the same feature.
Measure unresolved mismatches, unexpected renewals after an approved cancellation and access complaints after adjustments. Those checks are more informative than counting refund operations alone.
A reliable product does not force the customer or support agent to infer access from the money movement. It records the decision, performs the correct channel operation and confirms the state the customer can actually use.
Sources
Something we should clarify?
Suggest a correction


