Overview
The TranscriptionResult class represents the output of a transcription operation. It contains the transcribed text, detailed segment information, language detection results, and performance timing data.
Class Definition
open class TranscriptionResult: Codable, @unchecked Sendable
Initializer
public init(
text: String,
segments: [TranscriptionSegment],
language: String,
timings: TranscriptionTimings,
seekTime: Float? = nil
)
Complete transcribed text
Array of transcription segments with timestamps and metadata
Detected or specified language code
Performance timing information
Seek time offset in seconds (for chunked audio)
Properties
The complete transcribed text. All segments are concatenated together.
Array of transcription segments, each containing:
- Text content
- Start and end timestamps
- Token information
- Quality metrics (log probabilities, compression ratio)
- Optional word-level timestamps
ISO 639-1 language code (e.g., “en” for English, “es” for Spanish) detected or specified for this transcription.
Detailed performance metrics including:
- Model loading time
- Audio processing time
- Encoding time
- Decoding time
- Total pipeline duration
- Real-time factor
Seek time offset in seconds when this result is part of a chunked transcription.
Computed Properties
Flat array of all word-level timings across all segments. Only populated when wordTimestamps is enabled in DecodingOptions.
Methods
logSegments()
Logs all segments with timestamps and text to the console.
public func logSegments()
[Segment 0] [00:00.00 --> 00:03.50] Hello, this is a test.
[Segment 1] [00:03.50 --> 00:07.20] This is the second segment.
logTimings()
Logs detailed performance timing information to the console.
Output includes:
- Audio loading time
- Audio processing time
- Mel spectrogram computation time
- Encoding time
- Decoding time breakdown
- Total pipeline duration
- Tokens per second
- Real-time factor
TranscriptionSegment
Each segment in the segments array contains detailed information:
public struct TranscriptionSegment: Hashable, Codable, Sendable
Properties
Unique identifier for the segment
Seek position in the audio (in samples)
Start timestamp in seconds
Transcribed text for this segment
Token IDs generated for this segment
Log probabilities for each token
Sampling temperature used for this segment
Average log probability of all tokens (quality indicator)
Text compression ratio (detects repetitive output)
Probability that this segment contains no speech
Optional array of word-level timings (only when wordTimestamps is enabled)
Computed duration of the segment (end - start)
WordTiming
When word-level timestamps are enabled, each word includes:
public struct WordTiming: Hashable, Codable, Sendable
Properties
Token IDs that comprise this word
Start timestamp in seconds
Confidence probability for this word
Computed duration (end - start)
TranscriptionTimings
Detailed performance metrics:
public struct TranscriptionTimings: Codable, Sendable
Properties
Total time spent loading models
Time spent loading and converting audio
Time spent processing audio samples
Time spent computing mel spectrograms
Time spent in audio encoder
Time spent in text decoder predictions
Total time spent in decoding loop
Total end-to-end pipeline duration
Computed: tokens generated per second
Computed: ratio of processing time to audio duration (< 1.0 means faster than real-time)
Computed: inverse of real-time factor (> 1.0 means faster than real-time)
Example Usage
Basic Transcription
import WhisperKit
let whisperKit = try await WhisperKit()
let results = try await whisperKit.transcribe(
audioPath: "/path/to/audio.wav"
)
for result in results {
print("Language: \(result.language)")
print("Text: \(result.text)")
print("Segments: \(result.segments.count)")
}
Access Segments
for segment in result.segments {
print("[\(segment.start)s - \(segment.end)s]: \(segment.text)")
print(" Confidence: \(segment.avgLogprob)")
print(" No speech prob: \(segment.noSpeechProb)")
}
Word-Level Timestamps
let options = DecodingOptions(
wordTimestamps: true
)
let results = try await whisperKit.transcribe(
audioPath: "/path/to/audio.wav",
decodeOptions: options
)
for result in results {
for word in result.allWords {
print("\(word.word) [\(word.start)s - \(word.end)s]")
}
}
let result = results.first!
print("Real-time factor: \(result.timings.realTimeFactor)")
if result.timings.realTimeFactor < 1.0 {
print("Processing faster than real-time!")
}
print("Tokens per second: \(result.timings.tokensPerSecond)")
print("Total time: \(result.timings.fullPipeline)s")
print("Audio duration: \(result.timings.inputAudioSeconds)s")
// Log detailed breakdown
result.logTimings()
Quality Filtering
// Filter out low-quality segments
let highQualitySegments = result.segments.filter { segment in
segment.avgLogprob > -0.5 && // Good confidence
segment.noSpeechProb < 0.3 && // Low silence probability
segment.compressionRatio < 2.0 // Not repetitive
}
for segment in highQualitySegments {
print(segment.text)
}
func exportToSRT(result: TranscriptionResult) -> String {
var srt = ""
for (index, segment) in result.segments.enumerated() {
let startTime = formatTimestamp(segment.start)
let endTime = formatTimestamp(segment.end)
srt += "\(index + 1)\n"
srt += "\(startTime) --> \(endTime)\n"
srt += "\(segment.text.trimmingCharacters(in: .whitespaces))\n\n"
}
return srt
}
func formatTimestamp(_ seconds: Float) -> String {
let hours = Int(seconds) / 3600
let minutes = (Int(seconds) % 3600) / 60
let secs = Int(seconds) % 60
let millis = Int((seconds - Float(Int(seconds))) * 1000)
return String(format: "%02d:%02d:%02d,%03d", hours, minutes, secs, millis)
}
// Usage
let srtContent = exportToSRT(result: results.first!)
print(srtContent)
Monitor Progress
let results = try await whisperKit.transcribe(
audioPath: "/path/to/audio.wav"
) { progress in
print("Current text: \(progress.text)")
print("Tokens: \(progress.tokens.count)")
if let temp = progress.temperature {
print("Temperature: \(temp)")
}
return true // Continue
}
