> ## Documentation Index
> Fetch the complete documentation index at: https://learn.social.plus/llms.txt
> Use this file to discover all available pages before exploring further.

# Delete Story

> Soft delete or hard delete stories with StoryRepository deletion APIs.

Story repositories expose soft delete and hard delete operations. Soft delete marks a story as deleted and removes it from normal story collections. Hard delete passes the permanent-delete flag to the backend.

<Warning>
  Treat hard delete as irreversible from the client perspective. Do not offer it in user-facing flows without confirmation.
</Warning>

## Parameters

| Operation   | Parameter | Required | Description                                 |
| ----------- | --------- | -------- | ------------------------------------------- |
| Soft delete | `storyId` | Yes      | Story ID to soft delete.                    |
| Hard delete | `storyId` | Yes      | Story ID to hard delete after confirmation. |

## Soft Delete

Soft delete a story when the item should disappear from normal story surfaces while preserving deleted-state semantics.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { StoryRepository } from '@amityco/ts-sdk';

  const deleted = await StoryRepository.softDeleteStory(storyId);
  showSuccessMessage(deleted);
  ```

  ```swift iOS theme={null}
  try await storyRepository.softDeleteStory(storyId: "story-id")
  showSuccessMessage("Story soft deleted")
  ```

  ```kotlin Android theme={null}
  fun softDeleteStory(
      storyRepository: AmityStoryRepository,
      storyId: String
  ) {
      storyRepository.softDeleteStory(storyId = storyId)
          .doOnComplete { showSuccessMessage("Story soft deleted") }
          .doOnError { error -> showErrorMessage(error = error) }
          .subscribe()
  }
  ```

  ```dart Flutter theme={null}
  Future<void> softDeleteStory(String storyId) async {
    await AmitySocialClient.newStoryRepository().softDeleteStory(
      storyId: storyId,
    );
  }
  ```
</CodeGroup>

## Hard Delete

Hard delete a story only after the product confirms permanent removal is intended.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { StoryRepository } from '@amityco/ts-sdk';

  const deleted = await StoryRepository.hardDeleteStory(storyId);
  showSuccessMessage(deleted);
  ```

  ```swift iOS theme={null}
  try await storyRepository.hardDeleteStory(storyId: "story-id")
  showSuccessMessage("Story hard deleted")
  ```

  ```kotlin Android theme={null}
  fun hardDeleteStory(
      storyRepository: AmityStoryRepository,
      storyId: String
  ) {
      storyRepository.hardDeleteStory(storyId = storyId)
          .doOnComplete { showSuccessMessage("Story hard deleted") }
          .doOnError { error -> showErrorMessage(error = error) }
          .subscribe()
  }
  ```

  ```dart Flutter theme={null}
  Future<void> hardDeleteStory(String storyId) async {
    await AmitySocialClient.newStoryRepository().hardDeleteStory(
      storyId: storyId,
    );
  }
  ```
</CodeGroup>

## Choosing a Delete Type

| Delete type | Use when                                                                                              |
| ----------- | ----------------------------------------------------------------------------------------------------- |
| Soft delete | You want the story removed from normal story surfaces while preserving delete semantics in SDK state. |
| Hard delete | You need a permanent deletion request and have confirmed the action with the user or moderator.       |

## Related Topics

<CardGroup cols={2}>
  <Card title="Get Stories" href="../retrieval/get-stories" icon="list">
    Observe collections after delete operations.
  </Card>

  <Card title="Create Story" href="../creation/create-story" icon="plus">
    Create new story content.
  </Card>
</CardGroup>