SecureSpeakAI Deepfake Detection API

import requests

API_KEY = "your_api_key_here"
headers = {"Authorization": f"Bearer {API_KEY}"}

with open("audio-sample.wav", "rb") as f:
    response = requests.post(
        "https://securespeak-api-1064980124131.us-central1.run.app/analyze_file",
        headers=headers,
        files={"file": f}
    )

result = response.json()
print(f"Is Deepfake: {result['is_deepfake']}")
print(f"Confidence: {result['confidence']}")

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

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

const response = await axios.post(
  'https://securespeak-api-1064980124131.us-central1.run.app/analyze_file',
  form,
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      ...form.getHeaders()
    }
  }
);

console.log(response.data);

import java.io.*;
import java.net.http.*;
import java.nio.file.*;

public class SecureSpeakAnalyzer {
    private static final String API_URL = "https://securespeak-api-1064980124131.us-central1.run.app";
    private final String apiKey;
    private final HttpClient httpClient;
    
    public SecureSpeakAnalyzer(String apiKey) {
        this.apiKey = apiKey;
        this.httpClient = HttpClient.newHttpClient();
    }
    
    public String analyzeFile(String filePath) throws Exception {
        byte[] audioData = Files.readAllBytes(Paths.get(filePath));
        
        String boundary = "----WebKitFormBoundary" + System.currentTimeMillis();
        String multipartBody = createMultipartBody(audioData, "audio-sample.wav", boundary);
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL + "/analyze_file"))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "multipart/form-data; boundary=" + boundary)
                .POST(HttpRequest.BodyPublishers.ofString(multipartBody))
                .build();
        
        HttpResponse response = httpClient.send(request, 
                HttpResponse.BodyHandlers.ofString());
        
        return response.body();
    }
    
    private String createMultipartBody(byte[] fileData, String fileName, String boundary) {
        StringBuilder builder = new StringBuilder();
        builder.append("--").append(boundary).append("\r\n");
        builder.append("Content-Disposition: form-data; name=\"file\"; filename=\"")
               .append(fileName).append("\"\r\n");
        builder.append("Content-Type: audio/wav\r\n\r\n");
        builder.append(new String(fileData));
        builder.append("\r\n--").append(boundary).append("--\r\n");
        return builder.toString();
    }
}

// Usage
SecureSpeakAnalyzer analyzer = new SecureSpeakAnalyzer("your_api_key_here");
String result = analyzer.analyzeFile("audio-sample.wav");
System.out.println("Result: " + result);

import requests

API_KEY = "your_api_key_here"
headers = {
            "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {"url": "https://example.com/audio.mp3"}
response = requests.post(
    "https://securespeak-api-1064980124131.us-central1.run.app/analyze_url",
    headers=headers,
    json=payload
)

result = response.json()
print(f"Is Deepfake: {result['is_deepfake']}")
print(f"Confidence: {result['confidence']}")

const axios = require('axios');

const response = await axios.post(
  'https://securespeak-api-1064980124131.us-central1.run.app/analyze_url',
  { url: 'https://example.com/audio.mp3' },
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    }
  }
);

console.log(response.data);

import java.net.http.*;
import java.net.URI;

public class SecureSpeakURLAnalyzer {
    private static final String API_URL = "https://securespeak-api-1064980124131.us-central1.run.app";
    private final String apiKey;
    private final HttpClient httpClient;
    
    public SecureSpeakURLAnalyzer(String apiKey) {
        this.apiKey = apiKey;
        this.httpClient = HttpClient.newHttpClient();
    }
    
    public String analyzeURL(String audioUrl) throws Exception {
        String jsonPayload = String.format("{\"url\": \"%s\"}", audioUrl);
        
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL + "/analyze_url"))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
    .build();
        
        HttpResponse response = httpClient.send(request, 
                HttpResponse.BodyHandlers.ofString());
        
        return response.body();
    }
}

// Usage
SecureSpeakURLAnalyzer analyzer = new SecureSpeakURLAnalyzer("your_api_key_here");
String result = analyzer.analyzeURL("https://example.com/audio.mp3");
System.out.println("Result: " + result);

import requests

API_KEY = "your_api_key_here"
headers = {"Authorization": f"Bearer {API_KEY}"}

with open("audio-sample.wav", "rb") as audio_file:
    response = requests.post(
        "https://securespeak-api-1064980124131.us-central1.run.app/analyze_live",
        headers=headers,
        files={"file": audio_file}
    )

result = response.json()
print(f"Is Deepfake: {result['is_deepfake']}")
print(f"Confidence: {result['confidence']}")
print(f"Duration: {result['audio_metadata']['duration_sec']} seconds")
print(f"Cost: ${result['audio_metadata']['duration_sec'] * 0.032:.3f}")

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

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

const response = await axios.post(
  'https://securespeak-api-1064980124131.us-central1.run.app/analyze_live',
  form,
  {
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      ...form.getHeaders()
    }
  }
);

console.log('Result:', response.data);
console.log(`Duration: ${response.data.audio_metadata.duration_sec} seconds`);
console.log(`Cost: $${(response.data.audio_metadata.duration_sec * 0.032).toFixed(3)}`);

import java.io.*;
import java.net.http.*;
import java.nio.file.*;

public class SecureSpeakLiveAnalyzer {
    private static final String API_URL = "https://securespeak-api-1064980124131.us-central1.run.app";
    private final String apiKey;
    private final HttpClient httpClient;
    
    public SecureSpeakLiveAnalyzer(String apiKey) {
        this.apiKey = apiKey;
        this.httpClient = HttpClient.newHttpClient();
    }
    
    public String analyzeLiveAudio(byte[] audioData) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL + "/analyze_live"))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "audio/wav")
                .POST(HttpRequest.BodyPublishers.ofByteArray(audioData))
    .build();
        
        HttpResponse response = httpClient.send(request, 
                HttpResponse.BodyHandlers.ofString());
        
        return response.body();
    }
    
    public String analyzeLiveAudioFromFile(String filePath) throws Exception {
        byte[] audioData = Files.readAllBytes(Paths.get(filePath));
        return analyzeLiveAudio(audioData);
    }
}

// Usage
SecureSpeakLiveAnalyzer analyzer = new SecureSpeakLiveAnalyzer("your_api_key_here");
String result = analyzer.analyzeLiveAudioFromFile("audio-sample.wav");
System.out.println("Result: " + result);

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

class LiveVoiceVerifier {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.apiUrl = 'https://securespeak-api-1064980124131.us-central1.run.app';
        this.isRecording = false;
    }
    
    startVerification() {
        this.isRecording = true;
        this.continuousAnalysis();
    }
    
    continuousAnalysis() {
        if (!this.isRecording) return;
        
        // Record 7-second chunk
        this.recordChunk(7000).then(audioBuffer => {
            // Analyze with API
            return this.analyzeAudio(audioBuffer);
        }).then(result => {
            // Handle result
            if (result.is_deepfake) {
                console.log(`🚨 DEEPFAKE DETECTED - Confidence: ${result.confidence_score}%`);
            } else {
                console.log(`✅ Voice Authentic - Confidence: ${result.confidence_score}%`);
            }
            
            // Continue analysis
            setTimeout(() => this.continuousAnalysis(), 1000);
        }).catch(console.error);
    }
    
    recordChunk(duration) {
        return new Promise((resolve) => {
            const micInstance = mic({ rate: '44100', channels: '1', debug: false });
            const micInputStream = micInstance.getAudioStream();
            const chunks = [];
            
            micInputStream.on('data', data => chunks.push(data));
            micInstance.start();
            
            setTimeout(() => {
                micInstance.stop();
                resolve(Buffer.concat(chunks));
            }, duration);
        });
    }
    
    async analyzeAudio(audioBuffer) {
        const response = await axios.post(
            `${this.apiUrl}/analyze_live`,
            audioBuffer,
            {
                headers: {
                    'Authorization': `Bearer ${this.apiKey}`,
                    'Content-Type': 'audio/wav'
                }
            }
        );
        return response.data;
    }
}

// Usage
const verifier = new LiveVoiceVerifier('your_api_key');
verifier.startVerification();

# Record and analyze in real-time
#!/bin/bash

API_KEY="your_api_key"
API_URL="https://securespeak-api-1064980124131.us-central1.run.app/analyze_live"

while true; do
    # Record 7-second audio chunk
    ffmpeg -f avfoundation -i ":0" -t 7 -y temp_audio.wav
    
    # Send to API for analysis
    response=$(curl -s -X POST "$API_URL" \
        -H "Authorization: Bearer $API_KEY" \
        -H "Content-Type: audio/wav" \
        --data-binary @temp_audio.wav)
    
    # Parse and display result
    is_deepfake=$(echo "$response" | jq -r '.is_deepfake')
    confidence=$(echo "$response" | jq -r '.confidence_score')
    
    if [ "$is_deepfake" = "true" ]; then
        echo "🚨 DEEPFAKE DETECTED - Confidence: ${confidence}%"
    else
        echo "✅ Voice Authentic - Confidence: ${confidence}%"
    fi
    
    # Clean up temp file
    rm temp_audio.wav
    
    # Wait before next chunk
    sleep 1
done

package main

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

type LiveVoiceVerifier struct {
    APIKey string
    APIURL string
}

type AnalysisResult struct {
    IsDeepfake      bool    `json:"is_deepfake"`
    ConfidenceScore float64 `json:"confidence_score"`
    RequestID       string  `json:"request_id"`
}

func NewLiveVoiceVerifier(apiKey string) *LiveVoiceVerifier {
    return &LiveVoiceVerifier{
        APIKey: apiKey,
        APIURL: "https://securespeak-api-1064980124131.us-central1.run.app",
    }
}

func (v *LiveVoiceVerifier) StartVerification() {
    for {
        // Record 7-second audio chunk (implementation depends on audio library)
        audioData := v.recordChunk(7 * time.Second)
        
        // Analyze with API
        result, err := v.analyzeAudio(audioData)
        if err != nil {
            fmt.Printf("Error: %v\n", err)
            continue
        }
        
        // Handle result
        if result.IsDeepfake {
            fmt.Printf("🚨 DEEPFAKE DETECTED - Confidence: %.1f%%\n", result.ConfidenceScore)
        } else {
            fmt.Printf("✅ Voice Authentic - Confidence: %.1f%%\n", result.ConfidenceScore)
        }
        
        time.Sleep(1 * time.Second)
    }
}

func (v *LiveVoiceVerifier) analyzeAudio(audioData []byte) (*AnalysisResult, error) {
    req, err := http.NewRequest("POST", v.APIURL+"/analyze_live", bytes.NewReader(audioData))
    if err != nil {
        return nil, err
    }
    
    req.Header.Set("Authorization", "Bearer "+v.APIKey)
    req.Header.Set("Content-Type", "audio/wav")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var result AnalysisResult
    err = json.NewDecoder(resp.Body).Decode(&result)
    return &result, err
}

func (v *LiveVoiceVerifier) recordChunk(duration time.Duration) []byte {
    // Implementation depends on your audio capture library
    // This is a placeholder - use libraries like PortAudio bindings
    return []byte{}
}

func main() {
    verifier := NewLiveVoiceVerifier("your_api_key")
    verifier.StartVerification()
}

import java.net.http.*;
import java.util.concurrent.*;
import java.time.Duration;
import com.fasterxml.jackson.databind.ObjectMapper;

public class LiveVoiceVerifier {
    private static final String API_URL = "https://securespeak-api-1064980124131.us-central1.run.app";
    private final String apiKey;
    private final HttpClient httpClient;
    private final ObjectMapper objectMapper;
    private volatile boolean isRecording = false;
    
    public LiveVoiceVerifier(String apiKey) {
        this.apiKey = apiKey;
        this.httpClient = HttpClient.newHttpClient();
        this.objectMapper = new ObjectMapper();
    }
    
    public void startVerification() {
        this.isRecording = true;
        CompletableFuture.runAsync(this::continuousAnalysis);
    }
    
    private void continuousAnalysis() {
        while (isRecording) {
            try {
                // Record 7-second chunk (implementation depends on audio library)
                byte[] audioData = recordChunk(Duration.ofSeconds(7));
                
                // Analyze with API
                AnalysisResult result = analyzeAudio(audioData);
                
                // Handle result
                if (result.isDeepfake) {
                    System.out.printf("🚨 DEEPFAKE DETECTED - Confidence: %.1f%%\n", 
                                    result.confidenceScore);
                } else {
                    System.out.printf("✅ Voice Authentic - Confidence: %.1f%%\n", 
                                    result.confidenceScore);
                }
                
                Thread.sleep(1000); // Wait 1 second before next chunk
            } catch (Exception e) {
                System.err.println("Error during verification: " + e.getMessage());
            }
        }
    }
    
    private AnalysisResult analyzeAudio(byte[] audioData) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(API_URL + "/analyze_live"))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "audio/wav")
                .POST(HttpRequest.BodyPublishers.ofByteArray(audioData))
    .build();
        
        HttpResponse response = httpClient.send(request, 
                HttpResponse.BodyHandlers.ofString());
        
        return objectMapper.readValue(response.body(), AnalysisResult.class);
    }
    
    private byte[] recordChunk(Duration duration) {
        // Implementation depends on your audio capture library
        // This is a placeholder - use libraries like Java Sound API
        return new byte[0];
    }
    
    public void stopVerification() {
        this.isRecording = false;
    }
    
    public static class AnalysisResult {
        public boolean isDeepfake;
        public double confidenceScore;
        public String requestId;
    }
}

// Usage
LiveVoiceVerifier verifier = new LiveVoiceVerifier("your_api_key");
verifier.startVerification();

import requests

headers = {"Authorization": f"Bearer {firebase_token}"}
response = requests.get(
    "https://securespeak-api-1064980124131.us-central1.run.app/api/billing/usage",
    headers=headers
)

usage_data = response.json()
print(f"Account balance: ${usage_data['account_balance']}")
print(f"Total requests this month: {usage_data['monthly_requests']}")
print(f"Total cost this month: ${usage_data['monthly_cost']}")

const axios = require('axios');

const response = await axios.get(
  'https://securespeak-api-1064980124131.us-central1.run.app/api/billing/usage',
  {
    headers: {
      'Authorization': `Bearer ${firebaseToken}`
    }
  }
);

console.log('Account balance:', response.data.account_balance);
console.log('Monthly requests:', response.data.monthly_requests);
console.log('Monthly cost:', response.data.monthly_cost);