> 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.

# Create Transcription

POST https://api.sofer.ai/v1/transcriptions/
Content-Type: application/json

Create a new transcription

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

## Authentication

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

## Request

### Body (application/json)

This endpoint expects a TranscriptionRequest.

- `info` (TranscriptionRequestInfo, required) — Transcription parameters
- `audio_url` (string, optional) — A direct audio download URL or a page URL from an officially supported site. Supported site links are automatically resolved using the Link API's extraction logic, and the original URL is saved on the transcription. See [Get supported sites](/api-reference/link/get-supported-sites) for the current list. If extraction fails, the request returns the corresponding Link API error. Direct download URLs continue to work without extraction. Other streaming or preview links are not supported. Automatic extraction is available only for single transcriptions, not batch requests. Either audio_url or audio_file must be provided, but not both.
- `audio_file` (string, optional) — Base64 encoded audio file content. Either audio\_url or audio\_file must be provided, but not both. ## Base64 Encoding Example **Python:** ```python import base64 from soferai import SoferAI # Initialize client client = SoferAI(api_key="your_api_key_here") # Read and encode audio file with open("audio.mp3", "rb") as f: base64_audio = base64.b64encode(f.read()).decode('utf-8') # Create transcription request response = client.transcribe.create_transcription( audio_file=base64_audio, info={ "model": "v1", "primary_language": "en", "hebrew_word_format": ["he"], "title": "My Shiur Transcription" } ) print(f"Transcription ID: {response}") ```

## Response

### 200

The unique identifier for the newly created transcription. Use this ID to check the status of the transcription or to retrieve the transcription result.

- `UUID`

## Errors

### 401 Authentication Error

Authentication error

### 429 Rate Limit Error

Rate limit exceeded, or you have used up your quota

### 404 Link Not Found

Link is supported but not found

### 500 Link Error

Error extracting link

## Types

### TranscriptionRequestInfo

- `transliteration_style` (enum, optional) — Pronunciation used for Hebrew and Aramaic transliteration. Omit to use the saved account preference, or Sephardi when no preference is saved. Applies when the primary language is English and Hebrew words are transliterated.
  - Allowed values: `sefardi`, `ashkenazi`
- `model` (string, optional) — Model to be used for the transcription. Default is "v1". - v1: Our latest and most accurate model, especially for audio with longer stretches of Hebrew. Priced at 1.50 USD per hour of audio transcribed. - v0: Not generally recommended. Cheaper, but less accurate. Priced at 1.00 USD per hour.
- `id` (UUID, optional) — ID of the transcription. Any valid UUID version is accepted and preserved. If omitted, a UUIDv4 will be generated. An existing ID returns a conflict for external API requests.
- `title` (string, optional) — Title for the transcription, Default is "Untitled"
- `folder_id` (UUID, optional) — Optional owned document folder. Null or omitted creates the transcript at root.
- `primary_language` (enum, optional) — Specifies the primary language spoken in the audio content. Default is English. - en: English - he: Hebrew - yi: Yiddish - fr: French
  - Allowed values: `en`, `he`, `yi`, `fr`
- `hebrew_word_format` (list of enum, optional) — Relevant only when `primary_language` is `en`. This setting controls how Hebrew, Yiddish, and Aramaic speech is rendered. * Omit it or specify `["hybrid"]` (the default) to transliterate phrases of three words or fewer in italicized English letters and write longer phrases in Hebrew letters. * Specify `["he"]` to write all such speech in Hebrew letters. * Specify `["en"]` to transliterate all such speech into italicized English letters. * Specify `["en", "he"]` to provide every Hebrew word in both formats, with the transliteration in `<i>` tags. * When the primary language is not English, omit this field or specify `["he"]`; `["he"]` is the only supported format.
  - Allowed values: `en`, `he`, `hybrid`
- `num_speakers` (integer, optional) — Expected number of speakers in the audio. Default is 1. This field is mutually exclusive with `auto_detect_speakers`. If a number more than 1 is passed, it will be used for speaker labeling and adds **$0.30/hour**.
- `auto_detect_speakers` (boolean, optional) — Automatically detect the number of speakers in the audio. This field is mutually exclusive with `num_speakers`. If both are provided, the API returns a 400 error. Auto-detection adds **$0.30/hour**.

## Examples

**Request**

```json
{}
```

**Response**

```json
"d5e9c84f-c2b2-4bf4-b4b0-7ffd7a9ffc32"
```

**SDK Code**

```python
import requests

url = "https://api.sofer.ai/v1/transcriptions/"

payload = {}
headers = {
    "Authorization": "Bearer <apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.sofer.ai/v1/transcriptions/';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <apiKey>', 'Content-Type': 'application/json'},
  body: '{}'
};

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"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.sofer.ai/v1/transcriptions/"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <apiKey>")
	req.Header.Add("Content-Type", "application/json")

	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/")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{}"

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.post("https://api.sofer.ai/v1/transcriptions/")
  .header("Authorization", "Bearer <apiKey>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.sofer.ai/v1/transcriptions/', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <apiKey>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.sofer.ai/v1/transcriptions/");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <apiKey>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.sofer.ai/v1/transcriptions/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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()
```