import requests
import json


# Replace with your API key
api_key = "your_api_key"
# Replace with  order ID
order_id = "your_order_id"


# Define the API endpoint
api_url = f"https://api.tor.app/developer/files/{order_id}/content/export"

# Set up the payload with parameters
payload = {
    "export_type": "pdf",
    "include_speaker_names": True,
    "include_timestamps": True,
    "merge_same_speaker_segments": False,
    "is_single_paragraph": False,
    "paragraph_size": 1,
}

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

# Make the POST request
response = requests.post(api_url, json=payload, headers=headers)

# Check if the response status code indicates success
if response.status_code == 200:
    # Parse the JSON response body
    response_data = response.json()

    # Extract the pre-signed URL
    presigned_url = response_data.get("presigned_url")
    print("Pre-Signed URL:", presigned_url)

    # Extract and print the content
    content = response_data.get("content")
    print("Content:", content)
elif response.status_code == 202:
    print("Transcription is still processing. Please try again later.")
else:
    print("Failed to get a valid response:", response.status_code)
    print("Response Body:", response.text)

const axios = require('axios');

const apiKey = 'your_api_key';
const orderId = 'your_order_id';

const apiUrl = `https://api.tor.app/developer/files/${orderId}/content/export`;
const payload = {
    export_type: "pdf",
    include_speaker_names: true,
    include_timestamps: true,
    merge_same_speaker_segments: false,
    is_single_paragraph: false,
    paragraph_size: 1
};

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

axios.post(apiUrl, payload, { headers })
    .then(response => {
        if (response.status === 200) {
            console.log("Pre-Signed URL:", response.data.presigned_url);
            console.log("Content:", response.data.content);
        } else if (response.status === 202) {
            console.log("Transcription is still processing. Please try again later.");
        }
    })
    .catch(error => {
        console.error("Failed to get a valid response:", error.response ? error.response.status : error.message);
        console.error("Response Body:", error.response ? error.response.data : null);
    });

import okhttp3.*;
import org.json.JSONObject;

public class ExportFileContent {
    private static final String API_KEY = "your_api_key";
    private static final String ORDER_ID = "your_order_id";

    public static void main(String[] args) throws Exception {
        OkHttpClient client = new OkHttpClient();
        String apiUrl = "https://api.tor.app/developer/files/" + ORDER_ID + "/content/export";

        JSONObject payload = new JSONObject();
        payload.put("export_type", "pdf");
        payload.put("include_speaker_names", true);
        payload.put("include_timestamps", true);
        payload.put("merge_same_speaker_segments", false);
        payload.put("is_single_paragraph", false);
        payload.put("paragraph_size", 1);

        RequestBody body = RequestBody.create(payload.toString(), MediaType.parse("application/json"));

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

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                JSONObject responseData = new JSONObject(response.body().string());
                Syst

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

public class Program
{
    private static readonly string apiKey = "your_api_key";
    private static readonly string orderId = "your_order_id";

    public static async Task Main()
    {
        var client = new HttpClient();
        var apiUrl = $"https://api.tor.app/developer/files/{orderId}/content/export";

        var payload = new
        {
            export_type = "pdf",
            include_speaker_names = true,
            include_timestamps = true,
            merge_same_speaker_segments = false,
            is_single_paragraph = false,
            paragraph_size = 1
        };

        var jsonPayload = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");

        client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
        client.DefaultRequestHeaders.Add("Accept", "application/json");

        var response = await client.PostAsync(apiUrl, jsonPayload);

        if (response.IsSuccessStatusCode)
        {
            var responseData = await response.Content.ReadAsStringAsync();
            var data = JsonSerializer.Deserialize<JsonDocument>(responseData);
            Console.WriteLine("Pre-Signed URL: " + data.RootElement.GetProperty("presigned_url"));
            Console.WriteLine("Content: " + data.RootElement.GetProperty("content"));
        }
        else if (response.StatusCode == System.Net.HttpStatusCode.Accepted)
        {
            Console.WriteLine("Transcription is still processing. Please try again later.");
        }
        else
        {
            Console.WriteLine("Failed to get a valid response: " + response.StatusCode);
            Console.WriteLine("Response Body: " + await response.Content.ReadAsStringAsync());
        }
    }
}

package main

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

const (
	apiKey  = "your_api_key"
	orderId = "your_order_id"
)

func main() {
	apiUrl := fmt.Sprintf("https://api.tor.app/developer/files/%s/content/export", orderId)
	payload := map[string]interface{}{
		"export_type":               "pdf",
		"include_speaker_names":     true,
		"include_timestamps":        true,
		"merge_same_speaker_segments": false,
		"is_single_paragraph":       false,
		"paragraph_size":            1,
	}

	payloadBytes, _ := json.Marshal(payload)
	req, _ := http.NewRequest("POST", apiUrl, bytes.NewBuffer(payloadBytes))
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusOK {
		var result map[string]interface{}
		json.NewDecoder(resp.Body).Decode(&result)
		fmt.Println("Pre-Signed URL:", result["presigned_url"])
		fmt.Println("Content:", result["content"])
	} else if resp.StatusCode == http.StatusAccepted {
		fmt.Println("Transcription is still processing. Please try again later.")
	} else {
		fmt.Printf("Request failed with status: %d\n", resp.StatusCode)
	}
}

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

api_key = "your_api_key"
order_id = "your_order_id"

url = URI("https://api.tor.app/developer/files/#{order_id}/content/export")
payload = {
  export_type: "pdf",
  include_speaker_names: true,
  include_timestamps: true,
  merge_same_speaker_segments: false,
  is_single_paragraph: false,
  paragraph_size: 1,
}

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer #{api_key}"
request["Content-Type"] = "application/json"
request["Accept"] = "application/json"
request.body = payload.to_json

response = http.request(request)

if response.code.to_i == 200
  response_data = JSON.parse(response.body)
  puts "Pre-Signed URL: #{response_data['presigned_url']}"
  puts "Content: #{response_data['content']}"
elsif response.code.to_i == 202
  puts "Transcription is still processing. Please try again later."
else
  puts "Failed to get a valid response: #{response.code}"
  puts "Response Body: #{response.body}"
end

<?php
$apiKey = "your_api_key";
$orderId = "your_order_id";

$url = "https://api.tor.app/developer/files/$orderId/content/export";
$payload = [
    "export_type" => "pdf",
    "include_speaker_names" => true,
    "include_timestamps" => true,
    "merge_same_speaker_segments" => false,
    "is_single_paragraph" => false,
    "paragraph_size" => 1,
];

$headers = [
    "Authorization: Bearer $apiKey",
    "Content-Type: application/json",
    "Accept: application/json"
];

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode == 200) {
    $responseData = json_decode($response, true);
    echo "Pre-Signed URL: " . $responseData['presigned_url'] . "\n";
    echo "Content: " . $responseData['content'] . "\n";
} elseif ($httpCode == 202) {
    echo "Transcription is still processing. Please try again later.\n";
} else {
    echo "Failed to get a valid response: $httpCode\n";
    echo "Response Body: $response\n";
}
?>

import okhttp3.*
import org.json.JSONObject

fun main() {
    val apiKey = "your_api_key"
    val orderId = "your_order_id"
    val apiUrl = "https://api.tor.app/developer/files/$orderId/content/export"

    val payload = JSONObject()
    payload.put("export_type", "pdf")
    payload.put("include_speaker_names", true)
    payload.put("include_timestamps", true)
    payload.put("merge_same_speaker_segments", false)
    payload.put("is_single_paragraph", false)
    payload.put("paragraph_size", 1)

    val client = OkHttpClient()
    val body = RequestBody.create(MediaType.parse("application/json"), payload.toString())
    val request = Request.Builder()
        .url(apiUrl)
        .post(body)
        .addHeader("Authorization", "Bearer $apiKey")
        .addHeader("Content-Type", "application/json")
        .addHeader("Accept", "application/json")
        .build()

    client.newCall(request).execute().use { response ->
        if (response.isSuccessful) {
            val responseData = JSONObject(response.body()?.string())
            println("Pre-Signed URL: ${responseData.getString("presigned_url")}")
            println("Content: ${responseData.getString("content")}")
        } else if (response.code() == 202) {
            println("Transcription is still processing. Please try again later.")
        } else {
            println("Failed to get a valid response: ${response.code()}")
            println("Response Body: ${response.body()?.string()}")
        }
    }
}

import Foundation

let apiKey = "your_api_key"
let orderId = "your_order_id"

let apiUrl = URL(string: "https://api.tor.app/developer/files/\(orderId)/content/export")!

var request = URLRequest(url: apiUrl)
request.httpMethod = "POST"
request.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue("application/json", forHTTPHeaderField: "Accept")

let payload: [String: Any] = [
    "export_type": "pdf",
    "include_speaker_names": true,
    "include_timestamps": true,
    "merge_same_speaker_segments": false,
    "is_single_paragraph": false,
    "paragraph_size": 1,
]

request.httpBody = try! JSONSerialization.data(withJSONObject: payload, options: [])

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data, let httpResponse = response as? HTTPURLResponse {
        if httpResponse.statusCode == 200 {
            let responseData = try? JSONSerialization.jsonObject(with: data, options: []) as? [String: Any]
            print("Pre-Signed URL:", responseData?["presigned_url"] ?? "N/A")
            print("Content:", responseData?["content"] ?? "N/A")
        } else if httpResponse.statusCode == 202 {
            print("Transcription is still processing. Please try again later.")
        } else {
            print("Failed to get a valid response: \(httpResponse.statusCode)")
            print("Response Body:", String(data: data, encoding: .utf8) ?? "N/A")
        }
    }
}

task.resume()

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

void main() async {
  const apiKey = 'your_api_key';
  const orderId = 'your_order_id';

  final url = Uri.parse('https://api.tor.app/developer/files/$orderId/content/export');

  final payload = jsonEncode({
    "export_type": "pdf",
    "include_speaker_names": true,
    "include_timestamps": true,
    "merge_same_speaker_segments": false,
    "is_single_paragraph": false,
    "paragraph_size": 1,
  });

  final request = await HttpClient().postUrl(url)
    ..headers.set('Content-Type', 'application/json')
    ..headers.set('Authorization', 'Bearer $apiKey')
    ..headers.set('Accept', 'application/json')
    ..write(payload);

  final response = await request.close();

  if (response.statusCode == 200) {
    final responseBody = await response.transform(utf8.decoder).join();
    final responseData = jsonDecode(responseBody);
    print("Pre-Signed URL: ${responseData['presigned_url']}");
    print("Content: ${responseData['content']}");
  } else if (response.statusCode == 202) {
    print("Transcription is still processing. Please try again later.");
  } else {
    print("Failed to get a valid response: ${response.statusCode}");
    final responseBody = await response.transform(utf8.decoder).join();
    print("Response Body: $responseBody");
  }
}