Deepfake Detection

curl -X POST https://platform.modulate.ai/api/velma-2-synthetic-voice-detection-batch \
  -H "X-API-Key: $MODULATE_API_KEY" \
  -F "upload_file=@audio.mp3"

import os, requests

response = requests.post(
    "https://platform.modulate.ai/api/velma-2-synthetic-voice-detection-batch",
    headers={"X-API-Key": os.environ["MODULATE_API_KEY"]},
    files={"upload_file": open("audio.mp3", "rb")},
)
response.raise_for_status()
result = response.json()

print(f"{result['duration_ms']}ms, {len(result['frames'])} frames")
for frame in result["frames"]:
    print(f"  {frame['start_time_ms']}ms - {frame['end_time_ms']}ms  "
          f"{frame['verdict']}  ({frame['confidence']:.0%})")

import fs from "fs";
import FormData from "form-data";

const form = new FormData();
form.append("upload_file", fs.createReadStream("audio.mp3"), { filename: "audio.mp3" });

const response = await fetch(
  "https://platform.modulate.ai/api/velma-2-synthetic-voice-detection-batch",
  {
    method: "POST",
    headers: { "X-API-Key": process.env.MODULATE_API_KEY, ...form.getHeaders() },
    body: form,
  }
);

const result = await response.json();
for (const f of result.frames) {
  console.log(`${f.start_time_ms}ms - ${f.end_time_ms}ms  ${f.verdict}  ${f.confidence}`);
}

websocat "wss://platform.modulate.ai/api/velma-2-synthetic-voice-detection-streaming?api_key=$MODULATE_API_KEY&audio_format=s16le&sample_rate=16000&num_channels=1" \
  --binary - < audio.raw

import os, asyncio, json, websockets

API_KEY = os.environ["MODULATE_API_KEY"]
AUDIO_FILE = "audio.raw"
CHUNK_SIZE = 8192

async def stream():
    url = (
        f"wss://platform.modulate.ai/api/velma-2-synthetic-voice-detection-streaming"
        f"?api_key={API_KEY}&audio_format=s16le&sample_rate=16000&num_channels=1"
    )
    async with websockets.connect(url) as ws:
        async def send():
            with open(AUDIO_FILE, "rb") as f:
                while chunk := f.read(CHUNK_SIZE):
                    await ws.send(chunk)
            await ws.send("")  # end of stream

        async def receive():
            async for message in ws:
                msg = json.loads(message)
                if msg["type"] == "frame":
                    f = msg["frame"]
                    print(f"  {f['start_time_ms']}ms - {f['end_time_ms']}ms  "
                          f"{f['verdict']}  ({f['confidence']:.0%})")
                elif msg["type"] == "done":
                    print(f"Done: {msg['duration_ms']}ms, {msg['frame_count']} frames")
                    break
                elif msg["type"] == "error":
                    raise RuntimeError(msg["error"])

        await asyncio.gather(send(), receive())

asyncio.run(stream())

import { WebSocket } from "ws";
import { createReadStream } from "fs";

const url =
  `wss://platform.modulate.ai/api/velma-2-synthetic-voice-detection-streaming` +
  `?api_key=${process.env.MODULATE_API_KEY}` +
  `&audio_format=s16le&sample_rate=16000&num_channels=1`;

const ws = new WebSocket(url);

ws.on("open", () => {
  const stream = createReadStream("audio.raw", { highWaterMark: 8192 });
  stream.on("data", (chunk) => ws.send(chunk));
  stream.on("end", () => ws.send(""));
});

ws.on("message", (data) => {
  const msg = JSON.parse(data);
  if (msg.type === "frame") {
    const f = msg.frame;
    console.log(`${f.start_time_ms}ms - ${f.end_time_ms}ms  ${f.verdict}  ${f.confidence}`);
  } else if (msg.type === "done") {
    console.log(`Done: ${msg.duration_ms}ms, ${msg.frame_count} frames`);
    ws.close();
  } else if (msg.type === "error") {
    throw new Error(msg.error);
  }
});