import os, requests


# Set API key ENV variable or replace with your own API key
API_KEY = os.getenv("AIORNOT_API_KEY")
VOICE_ENDPOINT = "https://api.aiornot.com/v1/reports/voice"

with open("audio.mp3", "rb") as audio_file:
    files = {"file": audio_file}
    resp = requests.post(
        VOICE_ENDPOINT, 
        headers={"Authorization": f"Bearer {API_KEY}"},
        files=files,
        timeout=120
    )
    if resp.status_code != 200:
        raise Exception(f"Failed to analyze image: {resp.status_code} {resp.text}")

    print(resp.json())

curl --request POST \
  --url https://api.aiornot.com/v1/reports/voice \
  --header 'Authorization: Bearer $AIORNOT_API_KEY' \
  --form 'file=@audio.mp3' \
  --max-time 120

const fs = require('fs');
const FormData = require('form-data');
const fetch = require('node-fetch');

const API_KEY = process.env.AIORNOT_API_KEY;
const VOICE_ENDPOINT = 'https://api.aiornot.com/v1/reports/voice';

const form = new FormData();
form.append('file', fs.createReadStream('audio.mp3'));

fetch(VOICE_ENDPOINT, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    ...form.getHeaders()
  },
  body: form,
  timeout: 120000
})
  .then(response => {
    if (!response.ok) {
      throw new Error(`Failed to analyze voice: ${response.status} ${response.statusText}`);
    }
    return response.json();
  })
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

<?php

$API_KEY = getenv('AIORNOT_API_KEY');
$VOICE_ENDPOINT = 'https://api.aiornot.com/v1/reports/voice';

$curl = curl_init();

$audioFile = new CURLFile('audio.mp3', 'audio/mpeg', 'file');

curl_setopt_array($curl, [
  CURLOPT_URL => $VOICE_ENDPOINT,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 120,
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => [
    'file' => $audioFile
  ],
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer $API_KEY"
  ],
]);

$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} elseif ($httpCode !== 200) {
  echo "Failed to analyze voice: HTTP $httpCode - $response";
} else {
  $data = json_decode($response, true);
  print_r($data);
}

package main

import (
  "bytes"
  "fmt"
  "io"
  "io/ioutil"
  "mime/multipart"
  "net/http"
  "os"
  "time"
)

func main() {
  APIKey := os.Getenv("AIORNOT_API_KEY")
  voiceEndpoint := "https://api.aiornot.com/v1/reports/voice"

  file, err := os.Open("audio.mp3")
  if err != nil {
    panic(err)
  }
  defer file.Close()

  var requestBody bytes.Buffer
  writer := multipart.NewWriter(&requestBody)

  part, err := writer.CreateFormFile("file", "audio.mp3")
  if err != nil {
    panic(err)
  }

  _, err = io.Copy(part, file)
  if err != nil {
    panic(err)
  }

  err = writer.Close()
  if err != nil {
    panic(err)
  }

  client := &http.Client{
    Timeout: 120 * time.Second,
  }

  req, err := http.NewRequest("POST", voiceEndpoint, &requestBody)
  if err != nil {
    panic(err)
  }

  req.Header.Set("Authorization", "Bearer "+APIKey)
  req.Header.Set("Content-Type", writer.FormDataContentType())

  resp, err := client.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    panic(err)
  }

  if resp.StatusCode != 200 {
    fmt.Printf("Failed to analyze voice: %d %s\n", resp.StatusCode, string(body))
    return
  }

  fmt.Println(string(body))
}

import java.io.File;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import okhttp3.*;

public class VoiceAnalysis {
    public static void main(String[] args) {
        String apiKey = System.getenv("AIORNOT_API_KEY");
        String voiceEndpoint = "https://api.aiornot.com/v1/reports/voice";
        
        OkHttpClient client = new OkHttpClient.Builder()
            .readTimeout(120, TimeUnit.SECONDS)
            .build();
        
        File audioFile = new File("audio.mp3");
        
        RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("file", audioFile.getName(),
                RequestBody.create(MediaType.parse("audio/mpeg"), audioFile))
            .build();
        
        Request request = new Request.Builder()
            .url(voiceEndpoint)
            .header("Authorization", "Bearer " + apiKey)
            .post(requestBody)
            .build();
        
        try {
            Response response = client.newCall(request).execute();
            if (!response.isSuccessful()) {
                System.err.println("Failed to analyze voice: " + response.code() + " " + response.body().string());
            } else {
                System.out.println(response.body().string());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

require 'uri'
require 'net/http'

url = URI("https://api.aiornot.com/v1/reports/voice")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"file\"; filename=\"example-file\"\r\nContent-Type: application/octet-stream\r\n\r\n<string>\r\n-----011000010111000001101001--"

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

{
  "id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "report": {
    "confidence": 0.95,
    "duration": 120,
    "total_bytes": 362594,
    "md5": "db36d923800f6ca6b7f87cff8a19d1d1"
  },
  "created_at": "2023-11-07T05:31:56Z"
}