> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.sofer.ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.sofer.ai/_mcp/server.

# Get Transcription

GET https://api.sofer.ai/v1/transcriptions/{transcription_id}

Get transcription

Reference: https://docs.sofer.ai/api-reference/transcribe/get-transcription

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `transcription_id` (UUID, required) — ID of the transcription. Use the ID returned from the Create Transcription endpoint.

### Query parameters

- `filter_hebrew_word_format` (string, optional) — Optionally choose a Hebrew-word rendering for the response. If set to `en`, Hebrew characters are removed and timestamps exclude words tagged only with `he`. If set to `he`, italicized transliterations are removed and timestamps exclude words tagged only with `en`. If set to `hybrid`, the stored mixed rendering is returned without `en`/`he` filtering; it does not duplicate every Hebrew word in both formats.

## Response

### 200

- `text` (string, required) — This field contains the transcription text. For English-primary audio, the default `hybrid` format uses italicized English transliteration for short Hebrew phrases and Hebrew letters for longer phrases. With only `en` or `he`, Hebrew words use that format. If both `en` and `he` are requested, Hebrew words appear in both formats with the English transliteration in italics. If the primary language is Hebrew, the text is in Hebrew. If the primary language is French, the text is in French with Hebrew, Yiddish, and Aramaic words in Hebrew letters.
- `info` (TranscriptionInfo, required) — Additional information about the transcription
- `timestamps` (list of Timestamp, optional) — Timestamps object for the transcription. See the `timestamps` object for more details.

## Errors

### 404 Transcription Not Found

Transcription not found

### 401 Authentication Error

Authentication error

### 429 Rate Limit Error

Rate limit exceeded, or you have used up your quota

## Types

### TranscriptionInfo

- `id` (UUID, required) — ID of the transcription
- `title` (string, required) — Title of the transcription
- `created_at` (datetime, required) — When the transcription was created
- `status` (enum, required) — Current status of the transcription
  - Allowed values: `RECEIVED`, `PENDING`, `PROCESSING`, `COMPLETED`, `CANCELLED`, `FAILED`, `UPLOADED`, `INSUFFICIENT_FUNDS`
- `client_item_id` (string, optional) — Caller-defined per-item identifier for batch items. This is `null` for single transcriptions and for batch items submitted without a `client_item_id`.
- `folder_id` (UUID, optional) — Containing document folder, or null for root.
- `primary_language` (enum, optional) — The primary language of the audio content. This is null when an upload has not yet been configured for transcription.
  - Allowed values: `en`, `he`, `yi`, `fr`
- `hebrew_word_format` (list of enum, optional) — Indicates how Hebrew words are transcribed in the response when the primary language is English. * `hybrid` uses italicized English transliteration for short phrases and Hebrew letters for longer phrases. * Hebrew words are in Hebrew letters if "he" is specified. * Hebrew words are transliterated into English letters if "en" is specified. * If both "he" and "en" are specified, both versions are provided back-to-back for each Hebrew word. Transliterated Hebrew words are surrounded by \<i> tags in the response text. This is null when no Hebrew-word format has been configured for the upload.
  - Allowed values: `en`, `he`, `hybrid`
- `num_speakers` (integer, optional) — Number of speakers in the audio. This can be `null` while auto-detection is pending or if no count was determined.
- `duration` (double, optional) — Duration of the audio in seconds. If None, it means the duration was not calculated yet.
- `model` (string, optional) — Model used for the transcription. V1 is the latest and most accurate model, especially for audio with longer stretches of Hebrew. V0 is suitable for audio with fewer Hebrew words.

### Timestamp

- `word` (string, required) — Word
- `start` (double, required) — Start time of the timestamp
- `end` (double, required) — End time of the timestamp
- `hebrew_word_format` (list of enum, optional) — Specifies the format of Hebrew words in the transcription. Hebrew words are denoted as "he" for Hebrew letters or "en" for English transliteration. Non-Hebrew words are represented by null.
  - Allowed values: `en`, `he`, `hybrid`
- `speaker` (string, optional) — If speaker labeling was requested, indicates which speaker number spoke this word (Pro feature)

## Examples

**Response**

```json
{
  "text": "Welcome to today's <i>shiur</i> שיעור. We will discuss the <i>halacha</i> הלכה regarding...",
  "info": {
    "id": "d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32",
    "title": "My Shiur Transcription",
    "created_at": "2024-01-15T09:30:00Z",
    "status": "COMPLETED",
    "primary_language": "en",
    "hebrew_word_format": [
      "en",
      "he"
    ],
    "num_speakers": 1,
    "duration": 1802.5,
    "model": "v1"
  },
  "timestamps": [
    {
      "word": "Welcome",
      "start": 0,
      "end": 0.5,
      "hebrew_word_format": null,
      "speaker": "1"
    },
    {
      "word": "shiur",
      "start": 2.1,
      "end": 2.8,
      "hebrew_word_format": [
        "en"
      ],
      "speaker": "1"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32"

headers = {"Authorization": "Bearer <apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32';
const options = {method: 'GET', headers: {Authorization: 'Bearer <apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <apiKey>'

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")
  .header("Authorization", "Bearer <apiKey>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32', [
  'headers' => [
    'Authorization' => 'Bearer <apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.sofer.ai/v1/transcriptions/d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```