Guides

Transcribe Local File

Suggest Edits

📂 Upload a Local File for Transcription

Use this API to upload and transcribe a local audio or file. Start by obtaining an upload_url to securely upload your file and a public_url to initiate transcription. The transcription initiation will return an order_id for retrieving results.

⚠️ Note: Ensure the file path is correct and supported.

📋 Request Parameters

  • file_name (string): The name of your file to be uploaded using the upload_url.

🔄 Transcription Parameters

  • url (string): The public_url obtained after uploading, used to initiate transcription.
  • language (string): Language code in ISO format, e.g., en-US.
  • service (string): Type of transcription service:
    • Standard
    • Subtitle
  • folder_id (string, optional): ID of the folder for storage. Default is "Recent Files".
  • triggering_word (string, optional): A specific word to trigger a new line break in the transcription.

import json
import requests

# Step 1: Obtain the Upload URL
url = "https://api.tor.app/developer/transcription/local_file/get_upload_url"

# Replace with your actual API key
api_key = "your_api_key"

# Set up the headers, including the API key
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

# Request body with the file name
body = json.dumps({"file_name": "your_file_name"})

# Request to get the upload URL
response = requests.post(url, headers=headers, data=body)
if response.status_code == 200:
    response_json = response.json()
    upload_url = response_json["upload_url"]
    public_url = response_json[
        "public_url"
    ]  # URL to pass in initiate transcription step
    print("Upload URL obtained:", upload_url)
    print("Public URL obtained:", public_url)
else:
    print("Failed to get upload URL:", response.status_code, response.text)
    exit()

# Step 2: Upload the Local File
file_path = "path/to/your/file.mp3"  # Replace with your actual file path
with open(file_path, "rb") as file_data:
    upload_response = requests.put(upload_url, data=file_data)
    if upload_response.status_code == 200:
        print("File uploaded successfully")
    else:
        print("File upload failed:", upload_response.status_code, upload_response.text)
        exit()

# Step 3: Initiate Transcription for the Uploaded File
initiate_url = (
    "https://api.tor.app/developer/transcription/local_file/initiate_transcription"
)

# Configure transcription parameters
config = json.dumps(
    {
        "url": public_url,  # Passing public_url to initiate transcription
        "language": "en-US",
        "service": "Standard",
        # "folder_id": "your_folder_id",  # Optional folder_id
        # "triggering_word": "example",  # Optional triggering_word
    }
)

# Send request to initiate transcription
transcription_response = requests.post(initiate_url, headers=headers, data=config)
if transcription_response.status_code == 202:
    transcription_json = transcription_response.json()
    print(transcription_json["message"])
    print("Order ID:", transcription_json["order_id"])
else:
    print(
        "Failed to initiate transcription:",
        transcription_response.status_code,
        transcription_response.text,
    )


const axios = require('axios');
const fs = require('fs');

// Step 1: Obtain the Upload URL
const url = "https://api.tor.app/developer/transcription/local_file/get_upload_url";
const apiKey = "your_api_key"; // Replace with your actual API key

// Set up headers
const headers = {
  "Content-Type": "application/json",
  "Authorization": `Bearer ${apiKey}`,
  "Accept": "application/json"
};

// Request body with the file name
const body = JSON.stringify({ file_name: "your_file_name" });

(async () => {
  try {
    // Step 1: Get the upload URL
    const response = await axios.post(url, body, { headers });
    if (response.status === 200) {
      const { upload_url, public_url } = response.data;
      console.log("Upload URL obtained:", upload_url);
      console.log("Public URL obtained:", public_url);

      // Step 2: Upload the Local File
      const filePath = "path/to/your/file.mp3";
      const fileData = fs.createReadStream(filePath);
      const uploadResponse = await axios.put(upload_url, fileData);
      if (uploadResponse.status === 200) {
        console.log("File uploaded successfully");

        // Step 3: Initiate Transcription for the Uploaded File
        const initiateUrl = "https://api.tor.app/developer/transcription/local_file/initiate_transcription";
        const config = JSON.stringify({
          url: public_url,
          language: "en-US",
          service: "Standard",
        });
        const transcriptionResponse = await axios.post(initiateUrl, config, { headers });
        if (transcriptionResponse.status === 202) {
          console.log(transcriptionResponse.data.message);
          console.log("Order ID:", transcriptionResponse.data.order_id);
        } else {
          console.error("Failed to initiate transcription:", transcriptionResponse.status, transcriptionResponse.data);
        }
      } else {
        console.error("File upload failed:", uploadResponse.status, uploadResponse.data);
      }
    } else {
      console.error("Failed to get upload URL:", response.status, response.data);
    }
  } catch (error) {
    console.error("Error:", error.response ? error.response.data : error.message);
  }
})();



import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import okhttp3.*;

public class TranscribeFile {
    private static final String API_KEY = "your_api_key"; // Replace with your actual API key

    public static void main(String[] args) throws IOException {
        OkHttpClient client = new OkHttpClient();

        // Step 1: Obtain the Upload URL
        String url = "https://api.tor.app/developer/transcription/local_file/get_upload_url";
        MediaType JSON = MediaType.parse("application/json; charset=utf-8");
        RequestBody body = RequestBody.create(JSON, "{\"file_name\": \"your_file_name\"}");

        Request request = new Request.Builder()
                .url(url)
                .post(body)
                .addHeader("Authorization", "Bearer " + API_KEY)
                .addHeader("Content-Type", "application/json")
                .build();

        Response response = client.newCall(request).execute();
        if (response.isSuccessful()) {
            String responseData = response.body().string();
            JSONObject json = new JSONObject(responseData);
            String uploadUrl = json.getString("upload_url");
            String publicUrl = json.getString("public_url");
            System.out.println("Upload URL obtained: " + uploadUrl);
            System.out.println("Public URL obtained: " + publicUrl);

            // Step 2: Upload the Local File
            File file = new File("path/to/your/file.mp3");
            RequestBody fileBody = RequestBody.create(MediaType.parse("audio/mpeg"), file);

            Request uploadRequest = new Request.Builder().url(uploadUrl).put(fileBody).build();
            Response uploadResponse = client.newCall(uploadRequest).execute();
            if (uploadResponse.isSuccessful()) {
                System.out.println("File uploaded successfully");

                // Step 3: Initiate Transcription
                String initiateUrl = "https://api.tor.app/developer/transcription/local_file/initiate_transcription";
                String configJson = String.format("{\"url\": \"%s\", \"language\": \"en-US\", \"service\": \"Standard\"}", publicUrl);
                RequestBody configBody = RequestBody.create(JSON, configJson);

                Request transcriptionRequest = new Request.Builder()
                        .url(initiateUrl)
                        .post(configBody)
                        .addHeader("Authorization", "Bearer " + API_KEY)
                        .build();

                Response transcriptionResponse = client.newCall(transcriptionRequest).execute();
                if (transcriptionResponse.isSuccessful()) {
                    System.out.println("Transcription initiated successfully: " + transcriptionResponse.body().string());
                } else {
                    System.out.println("Failed to initiate transcription: " + transcriptionResponse.code());
                }
            } else {
                System.out.println("File upload failed: " + uploadResponse.code());
            }
        } else {
            System.out.println("Failed to get upload URL: " + response.code());
        }
    }
}



using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class TranscriptionExample
{
    private const string apiKey = "your_api_key"; // Replace with your actual API key

    public static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
        
        // Step 1: Obtain the Upload URL
        var url = "https://api.tor.app/developer/transcription/local_file/get_upload_url";
        var body = new StringContent(JsonSerializer.Serialize(new { file_name = "your_file_name" }), Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, body);

        if (response.IsSuccessStatusCode)
        {
            var jsonResponse = await response.Content.ReadAsStringAsync();
            var data = JsonDocument.Parse(jsonResponse);
            var uploadUrl = data.RootElement.GetProperty("upload_url").GetString();
            var publicUrl = data.RootElement.GetProperty("public_url").GetString();
            Console.WriteLine($"Upload URL obtained: {uploadUrl}");
            Console.WriteLine($"Public URL obtained: {publicUrl}");

            // Step 2: Upload the Local File
            var filePath = "path/to/your/file.mp3";
            using (var fileStream = new FileStream(filePath, FileMode.Open))
            {
                var fileContent = new StreamContent(fileStream);
                var uploadResponse = await client.PutAsync(uploadUrl, fileContent);
                if (uploadResponse.IsSuccessStatusCode)
                {
                    Console.WriteLine("File uploaded successfully");

                    // Step 3: Initiate Transcription
                    var initiateUrl = "https://api.tor.app/developer/transcription/local_file/initiate_transcription";
                    var config = new { url = publicUrl, language = "en-US", service = "Standard" };
                    var configContent = new StringContent(JsonSerializer.Serialize(config), Encoding.UTF8, "application/json");

                    var transcriptionResponse = await client.PostAsync(initiateUrl, configContent);
                    if (transcriptionResponse.IsSuccessStatusCode)
  



package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
)

const apiKey = "your_api_key" // Replace with your actual API key

func main() {
	// Step 1: Obtain the Upload URL
	url := "https://api.tor.app/developer/transcription/local_file/get_upload_url"
	headers := map[string]string{
		"Content-Type":  "application/json",
		"Authorization": "Bearer " + apiKey,
		"Accept":        "application/json",
	}
	body := map[string]string{"file_name": "your_file_name"}
	bodyBytes, _ := json.Marshal(body)

	request, _ := http.NewRequest("POST", url, bytes.NewBuffer(bodyBytes))
	for key, value := range headers {
		request.Header.Set(key, value)
	}

	client := &http.Client{}
	response, _ := client.Do(request)
	defer response.Body.Close()

	if response.StatusCode == http.StatusOK {
		var result map[string]interface{}
		json.NewDecoder(response.Body).Decode(&result)
		uploadUrl := result["upload_url"].(string)
		publicUrl := result["public_url"].(string)
		fmt.Println("Upload URL obtained:", uploadUrl)
		fmt.Println("Public URL obtained:", publicUrl)

		// Step 2: Upload the Local File
		file, _ := os.Open("path/to/your/file.mp3")
		defer file.Close()
		uploadRequest, _ := http.NewRequest("PUT", uploadUrl, file)
		uploadResponse, _ := client.Do(uploadRequest)
		defer uploadResponse.Body.Close()

		if uploadResponse.StatusCode == http.StatusOK {
			fmt.Println("File uploaded successfully")

			// Step 3: Initiate Transcription
			initiateUrl := "https://api.tor.app/developer/transcription/local_file/initiate_transcription"
			config := map[string]string{
				"url":      publicUrl,
				"language": "en-US",
				"service":  "Standard",
			}
			configBytes, _ := json.Marshal(config)
			transcriptionRequest, _ := http.NewRequest("POST", initiateUrl, bytes.NewBuffer(configBytes))
			transcriptionRequest.Header.Set("Authorization", "Bearer "+apiKey)
			transcriptionRequest.Header.Set("Content-Type", "application/json")

			transcriptionResponse, _ := client.Do(transcriptionRequest)
			defer transcriptionResponse.Body.Close()
			if transcriptionResponse.StatusCode == http.StatusAccepted {
				var transcriptionResult map[string]interface{}
				json.NewDecoder(transcriptionResponse.Body).Decode(&transcriptionResult)
				fmt.Println("Transcription initiated successfully:", transcriptionResult["message"])
			} else {
				fmt.Println("Failed to initiate transcription:", transcriptionResponse.StatusCode)
			}
		} else {
			fmt.Println("File upload failed:", uploadResponse.StatusCode)
		}
	} else {
		fmt.Println("Failed to get upload URL:", response.StatusCode)
	}
}



require 'net/http'
require 'json'
require 'uri'

# Step 1: Obtain the Upload URL
url = URI("https://api.tor.app/developer/transcription/local_file/get_upload_url")
api_key = "your_api_key" # Replace with your actual API key

headers = {
  "Content-Type" => "application/json",
  "Authorization" => "Bearer #{api_key}",
  "Accept" => "application/json"
}
body = { file_name: "your_file_name" }.to_json

response = Net::HTTP.post(url, body, headers)
if response.code.to_i == 200
  response_data = JSON.parse(response.body)
  upload_url = response_data["upload_url"]
  public_url = response_data["public_url"]
  puts "Upload URL obtained: #{upload_url}"
  puts "Public URL obtained: #{public_url}"

  # Step 2: Upload the Local File
  file_path = "path/to/your/file.mp3"
  file_data = File.open(file_path, "rb")
  upload_response = Net::HTTP.put(URI(upload_url), file_data.read)
  if upload_response.code.to_i == 200
    puts "File uploaded successfully"

    # Step 3: Initiate Transcription
    initiate_url = URI("https://api.tor.app/developer/transcription/local_file/initiate_transcription")
    config = { url: public_url, language: "en-US", service: "Standard" }.to_json
    transcription_response = Net::HTTP.post(initiate_url, config, headers)
    if transcription_response.code.to_i == 202
      transcription_data = JSON.parse(transcription_response.body)
      puts transcription_data["message"]
      puts "Order ID: #{transcription_data['order_id']}"
    else
      puts "Failed to initiate transcription: #{transcription_response.code}"
    end
  else
    puts "File upload failed: #{upload_response.code}"
  end
else
  puts "Failed to get upload URL: #{response.code}"
end



<?php
$apiKey = "your_api_key"; // Replace with your actual API key

// Step 1: Obtain the Upload URL
$url = "https://api.tor.app/developer/transcription/local_file/get_upload_url";
$headers = [
    "Content-Type: application/json",
    "Authorization: Bearer $apiKey",
    "Accept: application/json"
];
$body = json_encode(["file_name" => "your file.mp3"]);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

$responseData = json_decode($response, true);
if (isset($responseData["upload_url"])) {
    $uploadUrl = $responseData["upload_url"];
    $publicUrl = $responseData["public_url"];
    echo "Upload URL obtained: $uploadUrl\n";
    echo "Public URL obtained: $publicUrl\n";

    // Step 2: Upload the Local File
    $filePath = "path/to/your/file.mp3";
    if (!file_exists($filePath)) {
        die("File not found: $filePath\n");
    }

    $fileHandle = fopen($filePath, 'rb');
    if (!$fileHandle) {
        die("Failed to open file: $filePath\n");
    }

    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $uploadUrl);
    curl_setopt($ch, CURLOPT_PUT, true);
    curl_setopt($ch, CURLOPT_INFILE, $fileHandle);
    curl_setopt($ch, CURLOPT_INFILESIZE, filesize($filePath));
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HEADER, true); // Include headers in the output

    $uploadResponse = curl_exec($ch);
    $httpStatus = curl_getinfo($ch, CURLINFO_HTTP_CODE); // Get HTTP status code
    $effectiveUrl = curl_getinfo($ch, CURLINFO_EFFECTIVE_URL); // Get the actual URL

    curl_close($ch);
    fclose($fileHandle);

    echo "HTTP Status Code: $httpStatus\n";
    echo "Effective URL: $effectiveUrl\n";

    if ($httpStatus === 200 || $httpStatus === 204) {
        echo "File uploaded successfully\n";

        // Step 3: Initiate Transcription
        $initiateUrl = "https://api.tor.app/developer/transcription/local_file/initiate_transcription";
        $config = json_encode(["url" => $publicUrl, "language" => "en-US", "service" => "Standard"]);

        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $initiateUrl);
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_POSTFIELDS, $config);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        $transcriptionResponse = curl_exec($ch);
        curl_close($ch);

        $transcriptionData = json_decode($transcriptionResponse, true);
        if (isset($transcriptionData["order_id"])) {
            echo "Transcription initiated successfully: Order ID - " . $transcriptionData["order_id"] . "\n";
        } else {
            echo "Failed to initiate transcription\n";
            echo "Full Response: " . $transcriptionResponse . "\n";
        }
    } else {
        echo "File upload failed with HTTP Status: $httpStatus\n";
        echo "Upload Response: $uploadResponse\n";
    }
} else {
    echo "Failed to get upload URL\n";
    echo "Full Response: " . $response . "\n";
}
?>


import okhttp3.*
import org.json.JSONObject
import java.io.File

fun main() {
    val apiKey = "your_api_key" // Replace with your actual API key
    val client = OkHttpClient()

    // Step 1: Obtain the Upload URL
    val url = "https://api.tor.app/developer/transcription/local_file/get_upload_url"
    val body = RequestBody.create(MediaType.parse("application/json"), """{"file_name": "your_file_name"}""")
    val request = Request.Builder()
        .url(url)
        .post(body)
        .addHeader("Authorization", "Bearer $apiKey")
        .build()

    val response = client.newCall(request).execute()
    if (response.isSuccessful) {
        val responseData = JSONObject(response.body()!!.string())
        val uploadUrl = responseData.getString("upload_url")
        val publicUrl = responseData.getString("public_url")
        println("Upload URL obtained: $uploadUrl")
        println("Public URL obtained: $publicUrl")

        // Step 2: Upload the Local File
        val file = File("path/to/your/file.mp3")
        val fileBody = RequestBody.create(MediaType.parse("audio/mpeg"), file)
        val uploadRequest = Request.Builder().url(uploadUrl).put(fileBody).build()

        val uploadResponse = client.newCall(uploadRequest).execute()
        if (uploadResponse.isSuccessful) {
            println("File uploaded successfully")

            // Step 3: Initiate Transcription
            val initiateUrl = "https://api.tor.app/developer/transcription/local_file/initiate_transcription"
            val configBody = RequestBody.create(
                MediaType.parse("application/json"),
                """{"url": "$publicUrl", "language": "en-US", "service": "Standard"}"""
            )
            val transcriptionRequest = Request.Builder()
                .url(initiateUrl)
                .post(configBody)
                .addHeader("Authorization", "Bearer $apiKey")
                .build()

            val transcriptionResponse = client.newCall(transcriptionRequest).execute()
            if (transcriptionResponse.isSuccessful) {
                println("Transcription initiated successfully: ${transcriptionResponse.body()!!.string()}")
            } else {
                println("Failed to initiate transcription: ${transcriptionResponse.code()}")
            }
        } else {
            println("File upload failed: ${uploadResponse.code()}")
        }
    } else {
        println("Failed to get upload URL: ${response.code()}")
    }
}



import Foundation

let apiKey = "your_api_key" // Replace with your actual API key
let url = URL(string: "https://api.tor.app/developer/transcription/local_file/get_upload_url")!

// Step 1: Obtain the Upload URL
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try! JSONEncoder().encode(["file_name": "your_file_name"])

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data, let response = response as? HTTPURLResponse, response.statusCode == 200 {
        let json = try! JSONSerialization.jsonObject(with: data, options: []) as! [String: Any]
        let uploadUrl = json["upload_url"] as! String
        let publicUrl = json["public_url"] as! String
        print("Upload URL obtained: \(uploadUrl)")
        print("Public URL obtained: \(publicUrl)")

        // Step 2: Upload the Local File
        var uploadRequest = URLRequest(url: URL(string: uploadUrl)!)
        uploadRequest.httpMethod = "PUT"
        let fileData = try! Data(contentsOf: URL(fileURLWithPath: "path/to/your/file.mp3"))
        uploadRequest.httpBody = fileData

        let uploadTask = URLSession.shared.dataTask(with: uploadRequest) { uploadData, uploadResponse, uploadError in
            if let uploadResponse = uploadResponse as? HTTPURLResponse, uploadResponse.statusCode == 200 {
                print("File uploaded successfully")

                // Step 3: Initiate Transcription
                var initiateRequest = URLRequest(url: URL(string: "https://api.tor.app/developer/transcription/local_file/initiate_transcription")!)
                initiateRequest.httpMethod = "POST"
                initiateRequest.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
                initiateRequest.addValue("application/json", forHTTPHeaderField: "Content-Type")
                initiateRequest.httpBody = try! JSONEncoder().encode(["url": publicUrl, "language": "en-US", "service": "Standard"])

                let transcriptionTask = URLSession.shared.dataTask(with: initiateRequest) { transcriptionData, transcriptionResponse, transcriptionError in
                    if let transcriptionResponse = transcriptionResponse as? HTTPURLResponse, transcriptionResponse.statusCode == 202 {
                        let transcriptionJson = try! JSONSerialization.jsonObject(with: transcriptionData!, options: []) as! [String: Any]
                        print("Transcription initiated successfully: \(transcriptionJson["message"] ?? "")")
                        print("Order ID: \(transcriptionJson["order_id"] ?? "")")
                    } else {
                        print("Failed to initiate transcription")
                    }
                }
                transcriptionTask.resume()
            } else {
                print("File upload failed")
            }
        }
        uploadTask.resume()
    } else {
        print("Failed to get upload URL")
    }
}
task.resume()



import 'dart:convert';
import 'dart:io';

void main() async {
  final apiKey = 'your_api_key'; // Replace with your actual API key
  final url = Uri.parse('https://api.tor.app/developer/transcription/local_file/get_upload_url');

  // Step 1: Obtain the Upload URL
  final request = await HttpClient().postUrl(url);
  request.headers
    ..set('Content-Type', 'application/json')
    ..set('Authorization', 'Bearer $apiKey');
  request.add(utf8.encode(jsonEncode({'file_name': 'your_file_name'})));

  final response = await request.close();
  if (response.statusCode == 200) {
    final jsonResponse = await response.transform(utf8.decoder).join();
    final data = jsonDecode(jsonResponse);
    final uploadUrl = data['upload_url'];
    final publicUrl = data['public_url'];
    print('Upload URL obtained: $uploadUrl');
    print('Public URL obtained: $publicUrl');

    // Step 2: Upload the Local File
    final uploadRequest = await HttpClient().putUrl(Uri.parse(uploadUrl));
    final file = File('path/to/your/file.mp3');
    uploadRequest.add(await file.readAsBytes());

    final uploadResponse = await uploadRequest.close();
    if (uploadResponse.statusCode == 200) {
      print('File uploaded successfully');

      // Step 3: Initiate Transcription
      final transcriptionRequest = await HttpClient().postUrl(Uri.parse('https://api.tor.app/developer/transcription/local_file/initiate_transcription'));
      transcriptionRequest.headers.set('Authorization', 'Bearer $apiKey');
      transcriptionRequest.add(utf8.encode(jsonEncode({
        'url': publicUrl,
        'language': 'en-US',
        'service': 'Standard',
      })));

      final transcriptionResponse = await transcriptionRequest.close();
      if (transcriptionResponse.statusCode == 202) {
        final transcriptionJson = await transcriptionResponse.transform(utf8.decoder).join();
        print('Transcription initiated successfully: $transcriptionJson');
      } else {
        print('Failed to initiate transcription');
      }
    } else {
      print('File upload failed');
    }
  } else {
    print('Failed to get upload URL');
  }
}

🆕 Introducing Trigger Word for Transcription Line Breaks

Enhance your transcription experience with our latest feature - Trigger Word for Line Breaks! Now, you can specify a word that, when encountered during the transcription process, will automatically insert a new line in the transcript. This feature is perfect for creating clear and organized transcripts, especially for dialogue-heavy content such as interviews, meetings, and podcasts. Simply provide your desired trigger word in config parameters, and our advanced transcription service will take care of the rest, ensuring that your transcripts are easy to read and navigate.


config = json.dumps(
    {
        "url": public_url,  # Passing public_url to initiate transcription
        "language": "en-US",
        "service": "Standard",
        # "folder_id": "your_folder_id",  
        "triggering_word": "example", 
    }
)

Updated 23 days ago