---
title: "Cancel an event"
description: "Cancel an event in one call, then follow every attendee's refund and retry the ones that failed."
---

> Documentation Index
> Fetch the complete documentation index at: https://docs.sherpo.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Cancel an event

Canceling an event takes one call. The event stops selling, its sessions that haven't ended come off the schedule, and every ticket holder loses their ticket and gets back what they paid for it through your store. This guide cancels an event and follows its refunds. It uses the `sherpo` helper from [your first call](/merchant-api/first-call) and a token with `transaction:write`, plus `transaction:read` to list the refunds and `product:read` to read the cancellation again.

## Cancel it

<a href="/merchant-api/reference/cancel-event/">`POST /products/{product}/cancel`</a> takes the event and answers its cancellation:

```bash
curl -X POST 'https://api.sherpo.io/merchant/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/cancel' \
  -H "Authorization: Bearer $SHERPO_TOKEN" \
  -H 'Idempotency-Key: cancel-5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e'
```

```js
const answer = await sherpo('POST', '/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/cancel', {
  key: 'cancel-5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e',
});
```

Answers `200`, abridged:

```json
{
  "product_id": "5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e",
  "canceled_at": "2026-11-16T10:00:00.000Z",
  "subscriptions": 0,
  "finished_at": null,
  "removed": [
    {
      "id": "8d7c6b5a-4f3e-4d2c-9b1a-0f9e8d7c6b5a",
      "starts_at": "2026-12-04T18:00:00.000Z",
      "ends_at": "2026-12-04T21:00:00.000Z",
      "time_zone": "Europe/Rome",
      "venue": "Main hall",
      "online_label": null
    }
  ],
  "refunds": {
    "pending": 0,
    "refunded": 0,
    "failed": 0,
    "manual": 0
  }
}
```

- **`canceled_at`** is when you canceled it, and **`removed`** lists the sessions it took off the schedule: every one that hadn't ended, a session in progress included. One the door already checked guests in at ends at the cancellation instead, keeping their check-ins, and the door lets no one else in. Sessions that already ran stay, and no session can be added or moved afterwards.
- **`finished_at`** stays `null` while the attendees are handled, a page at a time right after the call, and is set once every one of them lost their ticket and was owed their email and refund.
- **`subscriptions`** counts the subscriptions to the event it stops billing.
- **`refunds`** counts the refunds by status: `pending`, `refunded`, `failed` and `manual`.

The event is discontinued for good, so nobody can buy it any more and reinstating it answers `conflict` on `status`. Its <a href="/merchant-api/reference/event-attendee-stats/">attendee stats</a> answer `remaining: 0` when it had a limit (and `null`, as before, when it had none), and content timed to a session it took off no longer waits for that session. A cancellation can't be undone: a second call answers `conflict` on `status`, and a product that isn't an event answers `conflict` on `category`. <a href="/merchant-api/reference/get-event-cancellation/">`GET /products/{product}/cancellation`</a> reads it again later, and answers `null` while the event stands.

## What attendees get

- **Their ticket ends.** Every ticket that held the event when you canceled it ends, scheduled ones too, and every subscription to it stops billing, one waiting on a failed renewal included. On the [guest list](/merchant-api/guides/event-guest-lists) each attendee reads `canceled`, with `cancel_reason` `canceled`, and your webhook endpoints hear `grant.revoked` for each ticket.
- **An email.** Everyone going gets the `event.canceled` email, saying the store canceled the event, which sessions came off the schedule and what goes back to them, or that the store refunds it directly. Your [webhook endpoints](/merchant-api/webhooks#events) hear the same `event.canceled` event. Someone whose ticket hadn't started yet isn't on the guest list, so they hear of their refund alone.
- **Buyers of group tickets.** A buyer who named a guest for every ticket they bought holds no ticket, so they aren't on the guest list. They get one `event.purchase_canceled` email for the event instead, naming their guests and saying how their money comes back: refunded to their original payment method, being refunded, or refunded by the store directly for a payment outside your store or a refund that failed. Your webhook endpoints hear `event.purchase_canceled` too. Their guests get the `event.canceled` email like everyone going, with no amount, since they paid nothing.
- **Requests close.** A request waiting for your approval or for a seat on the waitlist is declined, its seats given back, and its buyer gets the same `event.canceled` email rather than a decline. Approving a request on a canceled event answers `conflict`.
- **Their money back.** Each payment for the event through your store is refunded in full, to the original payment method, on your connected Stripe account. For a subscription, that's the payment for the period it was in, not earlier periods already used. Sherpo takes no fee, so its own part goes back too; Stripe keeps its processing fee on a refund, as for any refund you make. Each refund is recorded on its order like any other, so the order, your stats and the `order.refunded` and `refund.processed` events read it, and the buyer gets the refund email too. A free or granted ticket just ends.

A payment that goes through after you canceled, such as one waiting on the buyer's bank, and a ticket granted afterwards are ended and refunded the same way.

## Follow the refunds

<a href="/merchant-api/reference/list-event-refunds/">`GET /products/{product}/event_refunds`</a> pages the event's refunds, latest first, one per payment:

```bash
curl -g 'https://api.sherpo.io/merchant/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/event_refunds?filter[status]=failed&facets=status' \
  -H "Authorization: Bearer $SHERPO_TOKEN"
```

```js
const answer = await sherpo('GET', '/v1/stores/STORE_ID/products/5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e/event_refunds', {
  query: [
    ['filter[status]', 'failed'],
    ['facets', 'status'],
  ],
});
```

Answers `200`, abridged:

```json
{
  "items": [
    {
      "id": "3d2c1b0a-9f8e-4d7c-8b6a-5f4e3d2c1b0f",
      "product_id": "5c4b3a29-1807-4f6e-8d5c-4b3a29180f7e",
      "customer_id": "7e6d5c4b-3a29-4180-9f7e-6d5c4b3a2918",
      "order_id": "9a8b7c6d-5e4f-4321-8a9b-0c1d2e3f4a5b",
      "status": "failed",
      "amount": 4500,
      "currency": "eur",
      "exponent": 2,
      "failure": "processor_refused",
      "refund_id": null,
      "refunded_at": null,
      "customer": {
        "id": "7e6d5c4b-3a29-4180-9f7e-6d5c4b3a2918",
        "name": "Ada Lovelace",
        "email": "ada@example.com",
        "phone": null,
        "erased": false
      }
    }
  ],
  "cursor": null
}
```

- **`status`** is `pending` while it's being made, and while Stripe finishes a refund it took (its `processor_ref` is then set), `refunded` once the money went back (with **`refund_id`**, the refund on the order, and **`refunded_at`**; with no `refund_id` when the order's lines for the event were already given back another way), `failed` when it couldn't be, and `manual` for a sale paid outside your store, which you refund yourself.
- **`amount`**, in minor units with its `currency` and `exponent`, is what the payment's lines for the event had left to give back. It reads `null` without `revenue:read`.
- **`failure`** says why a failed one failed: `processor_refused` (Stripe refused it, such as a disputed charge or a balance too low), `account_gone` (your Stripe account is no longer connected), `processor_failed` (Stripe took it, then the card turned it back), `processor_unavailable` (Stripe couldn't be reached after several tries), `nothing_left` (the payment had nothing left to give back, or the order holds as many refunds as it can) or `order_unreconciled` (Stripe gave back money on the payment that its order can't record, so the order needs a look before this refund is tried again).
- **Filters** take `customer_id`, `order_id` and `status`, and `facets=status` counts the list by status.

Refunds Stripe can't take for now are tried again on their own a few times before they're marked `failed`. <a href="/merchant-api/reference/retry-event-refund/">`POST /event_refunds/{refund}/retry`</a> tries a failed one again once you fixed what stopped it; anything but a failed refund answers `conflict` on `status`.

When a refund fails after the buyer's cancellation email said it was on its way, the buyer gets one `event.refund_failed` email saying it couldn't go through and that you'll refund them directly, so refund them yourself or retry it. A refund that fails before their cancellation email is sent needs none: that email already says the store refunds them. A retry that fails again doesn't email them twice. Your [webhook endpoints](/merchant-api/webhooks#events) hear `event.refund_failed` for every failure, the email or not.

```bash
curl -X POST 'https://api.sherpo.io/merchant/v1/stores/STORE_ID/event_refunds/3d2c1b0a-9f8e-4d7c-8b6a-5f4e3d2c1b0f/retry' \
  -H "Authorization: Bearer $SHERPO_TOKEN" \
  -H 'Idempotency-Key: retry-3d2c1b0a-9f8e-4d7c-8b6a-5f4e3d2c1b0f'
```

```js
const answer = await sherpo('POST', '/v1/stores/STORE_ID/event_refunds/3d2c1b0a-9f8e-4d7c-8b6a-5f4e3d2c1b0f/retry', {
  key: 'retry-3d2c1b0a-9f8e-4d7c-8b6a-5f4e3d2c1b0f',
});
```

Answers `200`, abridged:

```json
{
  "id": "3d2c1b0a-9f8e-4d7c-8b6a-5f4e3d2c1b0f",
  "status": "pending",
  "failure": null
}
```

Source: https://docs.sherpo.io/merchant-api/guides/cancel-an-event/index.mdx
