# Delete snooze

> DELETE /v1/snoozes/{id} · Core resources API

Source: https://developer.kustomer.com/api/core-resources/delete-snooze

```http
DELETE https://{orgname}.api.kustomerapp.com/v1/snoozes/{id}
Authorization: Bearer <API key>
```

## Authorization

Requires any one of these roles: `org.permission.snooze.delete`; or legacy `org.admin.content.snooze.write`, `org.admin.snooze.write`. The API key or user must hold at least one of them. Legacy roles predate permission sets and still work.

Deletes a snooze.

## About Snooze options

Snooze options are the preset choices, such as "2 Hours" or "Tomorrow", that agents pick from when they snooze a conversation or custom object. Each option says how to work out the wake-up time; snoozing hides the item until then and reopens it when the time comes.

Snoozing parks work an agent can't finish yet. In the agent desktop, the snooze menu lists the org's enabled snooze options, and admins manage that list in the admin settings. When an agent picks one, the conversation's `status` becomes `snoozed` and its `snooze` attribute records when it should wake. At that time Kustomer sets it back to `open`. A customer reply also reopens a snoozed conversation early. These endpoints manage the menu of options, not individual snoozed conversations: to snooze or unsnooze a conversation, update the conversation itself.

#### Option types

| `type` | `value` | Example |
| --- | --- | --- |
| `relative` | A duration in milliseconds from the moment of snoozing. | `7200000` for "2 Hours" |
| `dynamic` | An object with a `day` rule and a `time` of day. | `{ "day": { "type": "tomorrow", "value": "" }, "time": "09:00 am" }` for "Tomorrow", or `"type": "absolute", "value": "monday"` for "Next Week" |
| `absolute` | A fixed date and time, as a timestamp in milliseconds. | The end of a promotion |

`name` is the label in the menu, and `enabled: false` hides an option without deleting it. New orgs start with "Tomorrow", "Next Week" and "2 Hours".

#### Conversations and custom objects

Each option has a `resource`: `conversation` (the default) or `kobject`. Custom object options belong to one Klass, so when you create one, send `resource: "kobject"` with `parentId` (the Klass ID) or `parentName` (the Klass name). Lists return one resource type at a time, `conversation` unless you pass `resource=kobject`, and you can narrow custom object options with `parentId` or `parentName`. An option's `resource` and Klass can't be changed after creation.

The number of options is capped per resource type, and per Klass for custom objects, by your Kustomer plan. Creating an option past the cap fails with `400`.

#### Why there are two sets of endpoints

The Core resources and Settings and configurations sections document the same `/v1/snoozes` endpoints, so both read and write the same list of options. Settings and configurations is the original, conversation-focused documentation, and it also lists the `parentId` and `parentName` filters. Core resources is the newer documentation: it adds custom object options, the `resource` field and the Klass lookup endpoint. Use either; the calls are interchangeable. Where the pages differ on how to target a Klass, send `resource`, `parentId` and `parentName` in the request body as described above.

#### Which endpoint to use

| To | Call |
| --- | --- |
| Build a snooze menu: list the options | [`GET /v1/snoozes`](https://developer.kustomer.com/api/core-resources/get-snoozes) (also documented [here](https://developer.kustomer.com/api/settings-and-configurations/get-all-snoozes)) |
| List options for one custom object Klass | [`GET /v1/snoozes/klass/{id}`](https://developer.kustomer.com/api/core-resources/get-snoozes-by-klass-id), or `GET /v1/snoozes?resource=kobject&parentId={klassId}` |
| Add an option | [`POST /v1/snoozes`](https://developer.kustomer.com/api/core-resources/create-snooze) (also [here](https://developer.kustomer.com/api/settings-and-configurations/create-a-snooze)) |
| Read one option | [`GET /v1/snoozes/{id}`](https://developer.kustomer.com/api/core-resources/get-snooze-by-id) (also [here](https://developer.kustomer.com/api/settings-and-configurations/get-snooze-by-id)) |
| Rename, retime, enable or disable an option | [`PUT /v1/snoozes/{id}`](https://developer.kustomer.com/api/core-resources/update-snooze) (also [here](https://developer.kustomer.com/api/settings-and-configurations/update-snooze-by-id)) |
| Remove an option | [`DELETE /v1/snoozes/{id}`](https://developer.kustomer.com/api/core-resources/delete-snooze) (also [here](https://developer.kustomer.com/api/settings-and-configurations/delete-snooze)) |

`PUT` changes only the fields you send (`name`, `value`, `type` or `enabled`), and `DELETE` removes the option permanently with `204`. Any user who can read settings can list options; changing them needs admin or snooze write permission.

Related: [Conversations and messages](https://developer.kustomer.com/docs/concepts/conversations-and-messages), [Sub-statuses](https://developer.kustomer.com/api/core-resources#sub-statuses), [Custom objects](https://developer.kustomer.com/docs/concepts/custom-objects)

### Recipes

#### 1. Snooze a conversation with one of the org's options

Let an integration, such as a bot waiting on a shipping update, snooze a conversation for the same durations agents use.

**Step 1.** [`GET /v1/snoozes`](https://developer.kustomer.com/api/core-resources/get-snoozes.md). Find the option by name. An option only describes how to work out a wake-up time; snoozing means computing that time yourself and setting it on the conversation. For a `relative` option, `value` is a duration in milliseconds.

```bash title="cURL"
curl "https://api.kustomerapp.com/v1/snoozes?resource=conversation" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```

```bash title="kusty"
DURATION=$(kusty api GET /v1/snoozes --query resource=conversation --all \
  | jq -r 'select(.data.attributes.name == "2 Hours" and .data.attributes.type == "relative" and .data.attributes.enabled) | .data.attributes.value')
```

**Step 2.** Work out the wake-up time as an ISO 8601 timestamp: now plus the duration.

```bash title="kusty"
WAKE_AT=$(jq -nr --argjson ms "$DURATION" '(now + $ms / 1000) | floor | todate')
```

**Step 3.** [`PUT /v1/conversations/{id}`](https://developer.kustomer.com/api/core-resources/update-conversation.md). Update the [conversation](https://developer.kustomer.com/api/core-resources#conversations) with `status: "snoozed"` and a `snooze` whose `status` is `scheduled` and whose `time` is the wake-up time. At that time Kustomer reopens it, and a customer reply reopens it sooner.

```bash title="cURL"
curl --request PUT "https://api.kustomerapp.com/v1/conversations/$CONVERSATION_ID" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data "{\"status\": \"snoozed\", \"snooze\": {\"status\": \"scheduled\", \"time\": \"$WAKE_AT\"}}"
```

```bash title="kusty"
kusty api PUT /v1/conversations/$CONVERSATION_ID \
  --field status=snoozed \
  --field snooze.status=scheduled \
  --field snooze.time=$WAKE_AT
```

> `dynamic` options such as "Tomorrow" use a day rule and a time of day instead of a duration, so pick a `relative` option, or compute the time with your own rule, when snoozing from an integration.

#### 2. Offer a snooze option until a fixed date

Add a menu choice such as "Until the sale ends" for a limited time, without creating duplicates when your setup script runs again, and hide it afterwards.

**Step 1.** [`GET /v1/snoozes`](https://developer.kustomer.com/api/core-resources/get-snoozes.md). Check whether the option already exists, so reruns don't add a second copy and count against the plan's cap on options.

```bash title="cURL"
curl "https://api.kustomerapp.com/v1/snoozes?resource=conversation" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```

```bash title="kusty"
SNOOZE_ID=$(kusty api GET /v1/snoozes --query resource=conversation --all \
  | jq -r 'select(.data.attributes.name == "Until the sale ends") | .data.id')
```

**Step 2.** [`POST /v1/snoozes`](https://developer.kustomer.com/api/core-resources/create-snooze.md). If it's missing, create it with `type: "absolute"` and the end time as a timestamp in milliseconds. Send `resource` in the body. Past the plan's cap, creating fails with `400`.

```bash title="cURL"
curl --request POST "https://api.kustomerapp.com/v1/snoozes" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"name": "Until the sale ends", "type": "absolute", "value": 1798761600000, "resource": "conversation", "enabled": true}'
```

```bash title="kusty"
kusty api POST /v1/snoozes \
  --field "name=Until the sale ends" \
  --field type=absolute \
  --field value:=1798761600000 \
  --field resource=conversation \
  --field enabled:=true
```

**Step 3.** [`PUT /v1/snoozes/{id}`](https://developer.kustomer.com/api/core-resources/update-snooze.md). When the date passes, hide the option with `enabled: false`. `PUT` changes only the fields you send, so you can turn it back on with new dates next season instead of creating another.

```bash title="cURL"
curl --request PUT "https://api.kustomerapp.com/v1/snoozes/$SNOOZE_ID" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"enabled": false}'
```

```bash title="kusty"
kusty api PUT /v1/snoozes/$SNOOZE_ID --field enabled:=false
```

#### 3. Add snooze options for a custom object Klass

Give agents working a custom object, such as returns, their own snooze menu.

**Step 1.** [`GET /v1/klasses`](https://developer.kustomer.com/api/core-resources/get-klasses.md). Find the [Klass](https://developer.kustomer.com/api/core-resources#klasses) ID by name.

```bash title="cURL"
curl "https://api.kustomerapp.com/v1/klasses?name=return" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```

```bash title="kusty"
KLASS_ID=$(kusty api GET /v1/klasses --query name=return | jq -r '.data[0].id')
```

**Step 2.** [`POST /v1/snoozes`](https://developer.kustomer.com/api/core-resources/create-snooze.md). Create each option with `resource: "kobject"` and the Klass as `parentId`, both in the body. The cap on options applies per Klass. Here `value` is three days in milliseconds.

```bash title="cURL"
curl --request POST "https://api.kustomerapp.com/v1/snoozes" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data "{\"name\": \"3 Days\", \"type\": \"relative\", \"value\": 259200000, \"resource\": \"kobject\", \"parentId\": \"$KLASS_ID\"}"
```

```bash title="kusty"
kusty api POST /v1/snoozes \
  --field "name=3 Days" \
  --field type=relative \
  --field value:=259200000 \
  --field resource=kobject \
  --field parentId=$KLASS_ID
```

**Step 3.** [`GET /v1/snoozes/klass/{id}`](https://developer.kustomer.com/api/core-resources/get-snoozes-by-klass-id.md). List the Klass's options to check the menu agents will see.

```bash title="cURL"
curl "https://api.kustomerapp.com/v1/snoozes/klass/$KLASS_ID" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```

```bash title="kusty"
kusty api GET /v1/snoozes/klass/$KLASS_ID --all --fields id,attributes.name,attributes.enabled
```

### Example object

A real record from [`GET /v1/snoozes/{id}`](https://developer.kustomer.com/api/core-resources/get-snooze-by-id.md):

```json
{
  "type": "snooze",
  "id": "567229511e4a481f0062f7fd",
  "attributes": {
    "name": "1 Hour",
    "enabled": true,
    "value": 3600,
    "type": "relative",
    "resource": "conversation",
    "createdAt": "2026-03-14T15:09:26.535Z",
    "updatedAt": "2026-03-14T15:09:26.535Z",
    "modifiedAt": "2026-03-14T15:09:26.535Z"
  },
  "relationships": {
    "org": {
      "data": {
        "type": "org",
        "id": "567229511e4a481f0062f7de"
      },
      "links": {
        "self": "/v1/orgs/567229511e4a481f0062f7de"
      }
    }
  },
  "links": {
    "self": "/v1/snoozes/567229511e4a481f0062f7fd"
  }
}
```

Fields:

- `attributes.name` (string): The label agents see in the snooze menu, such as "2 Hours" or "Tomorrow".
- `attributes.enabled` (boolean): Whether the option appears in the snooze menu. Set it to `false` to hide an option without deleting it.
- `attributes.value` (number): How to work out the wake-up time, depending on `type`: a duration in milliseconds for `relative` (one hour is `3600000`), a timestamp in milliseconds for `absolute`, or a `{ day, time }` object for `dynamic`.
- `attributes.type` (string): `relative`, `absolute` or `dynamic`, which decides how `value` is read.
- `attributes.resource` (string): `conversation` or `kobject`. Send it in the request body when you create an option; it can't be changed afterwards.

### Relationships

- Points to **Klasses** via `relationships.parentId`: The Klass a custom object snooze option belongs to, sent as `parentId` (or `parentName`) when the option is created. `GET /v1/snoozes/klass/{id}` lists the options for one Klass.

### Permissions

Fewest roles for a read-only integration: `org.permission.snooze.read`. For every endpoint: `org.permission.snooze.read`, `org.permission.snooze.create`, `org.permission.snooze.delete`, `org.permission.snooze.update`.

## Path parameters

| Name | Type | Required | Description |
| --- | --- | --- | --- |
| `id` | string | yes | Resource ID. |

## Responses

### 204

No Content

### 401

Unauthorized

### 403

Forbidden

### 404

Not Found

## Example request

```bash
curl --request DELETE \
  --url 'https://api.kustomerapp.com/v1/snoozes/60254e3ec413ae00571e3c96' \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```