Rate limits and audio limits

The limits below are the current defaults for the free plan. They can change; your code should handle 413, 422 and 429 responses rather than rely on exact numbers.

#Audio limits

Other limits:

• One recording per request.
• Up to 5 active enrollment samples per speaker.
• speaker_id: 1 to 64 characters from A-Z a-z 0-9 _ . : -.
• Idempotency-Key: 1 to 128 printable characters.

Audio checks happen before credits are reserved, so a file that fails them is not charged. Duration and speech are measured on the decoded audio, so the same recording can pass or fail regardless of its container or bitrate.

#Tips for usable audio

• Send the original recording when you can. Repeated lossy re-encoding removes detail that both models use.
• For enrollment, record the speaker alone, with little background noise. Use 10 seconds or more of clean speech per sample and enroll 2 to 3 samples from different sessions.
• Speaker verification uses a default threshold of 0.53 (cosine), chosen for a low false-accept rate: on a held-out split of Svarah (Indian-accented English) the team measured 0.12% false accepts and 2.75% false rejects. When enrollment and verification recordings come from different sessions and conditions, false rejects rise: about 10% for full utterances and about 22% for 3 second clips in the team's VoxCeleb test. See the decision threshold.
• Speaker verification is less reliable on 8 kHz telephone audio and codec-compressed audio (team-reported). Use wideband recordings where you can.
• The deepfake detection threshold (0.62) is tuned for English speech. Results for other languages, including Hindi, are less reliable.
• Deepfake scores for clips of 2 seconds or less are less reliable. Send longer recordings where you can.
• Trim long silences at the start and end. They count toward duration but not toward speech.

#Rate limits

Free endpoints (balance, usage, speakers, operations) count toward the per-key limit. Model operations count toward both the per-key and the per-account limits. A verification with detect_deepfake=true is one request that runs two operations.

When a limit is reached, the API returns 429 with a Retry-After header (in seconds):

#Model capacity

Model requests share a bounded queue. When it is full, the API returns 503 inference_overloaded with a Retry-After header instead of holding your request. A request that waits too long returns 504 inference_timeout. Neither is charged.

#Handling 429 and 503

Wait for Retry-After seconds and retry with the same Idempotency-Key. To stay under the concurrency limit, run at most two model requests at a time per account.

# cURL honours Retry-After when --retry is set
KEY=$(uuidgen)
curl https://platform.detectif.ai/v1/deepfake/detect --retry 4 \
  -H "Authorization: Bearer $DETECTIF_API_KEY" \
  -H "Idempotency-Key: $KEY" \
  -F "file=@call-recording.wav"

import os
import uuid
from concurrent.futures import ThreadPoolExecutor
import time
import requests

def detect(path):
    key = str(uuid.uuid4())
    for _ in range(5):
        with open(path, "rb") as f:
            resp = requests.post(
                "https://platform.detectif.ai/v1/deepfake/detect",
                headers={"Authorization": f"Bearer {os.environ['DETECTIF_API_KEY']}", "Idempotency-Key": key},
                files={"file": (os.path.basename(path), f)},
                timeout=120,
            )
        if resp.status_code in (429, 503):
            time.sleep(float(resp.headers.get("Retry-After", "2")))
            continue
        return resp.json()
    raise RuntimeError("still limited after 5 attempts")

files = ["a.wav", "b.wav", "c.wav", "d.wav"]
with ThreadPoolExecutor(max_workers=2) as pool:  # at most 2 model requests at a time
    for path, body in zip(files, pool.map(detect, files)):
        print(path, body.get("result", body.get("error")))

import { readFile } from "node:fs/promises";
import { basename } from "node:path";
import { randomUUID } from "node:crypto";

async function detect(path) {
  const key = randomUUID();
  const audio = await readFile(path);
  for (let attempt = 0; attempt < 5; attempt++) {
    const form = new FormData();
    form.append("file", new Blob([audio]), basename(path));
    const res = await fetch("https://platform.detectif.ai/v1/deepfake/detect", {
      method: "POST",
      headers: { Authorization: `Bearer ${process.env.DETECTIF_API_KEY}`, "Idempotency-Key": key },
      body: form,
    });
    if (res.status === 429 || res.status === 503) {
      const wait = Number(res.headers.get("retry-after") ?? 2);
      await new Promise((r) => setTimeout(r, wait * 1000));
      continue;
    }
    return res.json();
  }
  throw new Error("still limited after 5 attempts");
}

// At most 2 model requests at a time.
const queue = ["a.wav", "b.wav", "c.wav", "d.wav"];
async function worker() {
  for (let path; (path = queue.shift()); ) {
    const body = await detect(path);
    console.log(path, body.result ?? body.error);
  }
}
await Promise.all([worker(), worker()]);