# Recording

### Call's recording features

In some cases, you want to be able to record a meeting and share the recording with the participants later on. The StreamVideo SDK has support for this use-case.

<admonition type="note">
Recording requires the appropriate permissions to be configured for your call type in the Stream Dashboard. Users must have the `start-record-call` and `stop-record-call` capabilities to control recording.
</admonition>

In order to support this feature, you will need to use the `Call`'s recording features, available after you join a call.

#### Recording state

The recording state of the call is available via the `CallViewModel`'s `recordingState` published property. It's an `enum`, which has the following values:

- `noRecording` - default value, there's no recording on the call.
- `requested` - recording was requested by the current user.
- `recording` - recording is in progress.

If you are not using our `CallViewModel`, you can also listen to this state via the `Call`'s property `recordingState`.

#### Start a recording

To start a recording, you need to call the `startRecording` method of the call:

```swift
func startRecording() {
    Task {
        try await call.startRecording()
    }
}
```

This will change the current recording state of the call to `requested`. Since it takes several seconds before the recording is started, it's best to handle this state by presenting a progress indicator to provide a better user experience.

After the recording is started, the `recordingState` changes to `recording`.

#### Stop a recording

To stop a recording, you need to call the `stopRecording` method of the `Call`:

```swift
func stopRecording() {
    Task {
        try await call.stopRecording()
    }
}
```

This will change the current recording state of the call to `noRecording`.

#### Recording events

You can listen to the recording events and show visual indications to the users based on these events, by subscribing to the async stream of the `recordingEvents`:

```swift
func subscribeToRecordingEvents() {
    Task {
        for await event in call.subscribe() {
            switch event {
                case .typeCallRecordingStartedEvent(let recordingStartedEvent):
                    log.debug("received an event \(recordingStartedEvent)")
                    /* handle recording event */
                case .typeCallRecordingStoppedEvent(let recordingStoppedEvent):
                    log.debug("received an event \(recordingStoppedEvent)")
                    /* handle recording event */
                default:
                    break
            }
        }
    }
}
```

#### Search recordings

You can search for recordings in a video call, using the `Call`'s `listRecordings` method:

```swift
func loadRecordings() {
    Task {
        self.recordings = try await call.listRecordings()
    }
}
```

This will return a list of recordings, that contains information about the filename, URL, as well as the start and end time. You can use the URL to present the recording in a player. Here's an example in SwiftUI:

```swift
import SwiftUI
import StreamVideo
import AVKit

struct PlayerView: View {

    let recording: CallRecording

    var body: some View {
        Group {
            if let url = URL(string: recording.url) {
                VideoPlayer(player: AVPlayer(url:  url))
            } else {
                Text("Video can't be loaded")
            }
        }
    }
}
```

### Recording Storage

Recordings are stored according to your Stream dashboard configuration. By default, recordings are stored on Stream's servers and are available for download via the URL provided in the `CallRecording` object.

You can also configure external storage (such as S3) in your dashboard settings for more control over where recordings are stored.

### Recording Settings

When starting a recording, you can optionally specify custom settings. The recording configuration is typically set at the call type level in your dashboard, but can be customized per call if needed.

Recording properties available in `CallRecording`:

- `filename` - The name of the recording file
- `url` - The URL to download/stream the recording
- `startTime` - When the recording started
- `endTime` - When the recording ended


---

This page was last updated at 2026-03-06T17:09:11.891Z.

For the most recent version of this documentation, visit [https://getstream.io/video/docs/ios/advanced/recording/](https://getstream.io/video/docs/ios/advanced/recording/).