Can you trust the voice you just heard?
VoiceGuard AI answers that in under 300ms.

🚀 Try Live Demo  ·  📡 API Playground  ·  🐛 Report a Bug  ·  💡 Request Feature

VoiceGuard AI is a production-grade deepfake audio detection system that determines — in real time — whether a voice recording is authentic human speech or AI-synthesized audio.

As voice cloning tools like ElevenLabs, Murf, and PlayHT become disturbingly accessible, the ability to verify audio authenticity is no longer optional — it's critical for fraud prevention, digital forensics, and AI transparency.

This project was built for a CyberSecurity Hackathon and is fully deployed and publicly accessible.

• Uses Meta's Wav2Vec2-Large-XLSR-53 — one of the most powerful multilingual speech transformers ever released — for raw vocal fingerprinting, not just spectral features
• Real model, real data — trained on diverse human + AI audio with 4× augmentation
• Full-stack, production-deployed, with a polished cyberpunk frontend

Evaluated on a held-out test set of real and AI-generated audio samples

Performance may vary based on audio quality, background noise, and the TTS engine used to generate synthetic samples. Clips < 2 seconds may yield lower confidence.

  ┌─────────────────────────────────────────────────────────────────┐
  │                        CLIENT (Browser)                         │
  │            Drag & Drop / Record → Base64 encode audio           │
  └───────────────────────────┬─────────────────────────────────────┘
                              │  POST /detect-audio/
                              │  { audio_base64, audio_format }
                              ▼
  ┌─────────────────────────────────────────────────────────────────┐
  │                      FastAPI Backend                            │
  │                                                                 │
  │  1. Verify API Key (x-api-key or Authorization header)          │
  │  2. Decode Base64 → raw audio bytes                             │
  │  3. Librosa: load + resample to 16kHz                           │
  │  4. Wav2Vec2-Large-XLSR-53 → 1024-dim vocal embedding           │
  │  5. StandardScaler: normalize embedding                         │
  │  6. MLP Classifier: predict [human_prob, ai_prob]               │
  │  7. Return verdict + confidence score                           │
  └───────────────────────────┬─────────────────────────────────────┘
                              │
                              ▼
              ┌───────────────────────────────┐
              │         JSON Response         │
              │  {                            │
              │    is_ai_generated: bool,     │
              │    confidence_score: float,   │
              │    message: string            │
              │  }                            │
              └───────────────────────────────┘

Model Stack:

• Feature Extractor → facebook/wav2vec2-large-xlsr-53 (1024-dim embeddings)
• Classifier → MLP Classifier (MLPClassifier with hidden layers 128, 64), max_iter=500
• Scaler → StandardScaler (fitted on training set)
• Training augmentation → Original + Gaussian noise + Pitch ±2 semitones

Why MLP? Wav2Vec2 produces 1024-dimensional embeddings that capture highly non-linear speech phenomena; an MLP with hidden layers [128, 64] can learn these complex decision boundaries far more effectively than logistic regression, which is limited to linear separability in the original feature space.

Base URL: https://srv99x-voice-detector-live.hf.space
Interactive Docs: https://srv99x-voice-detector-live.hf.space/docs

Request Headers:

Content-Type: application/json
x-api-key: YOUR_API_KEY

or

Authorization: Bearer YOUR_API_KEY

Request Body:

{
  "audio_base64": "<BASE64_ENCODED_AUDIO>",
  "audio_format": "mp3",
  "language": "en"
}

Response:

{
  "is_ai_generated": true,
  "confidence_score": 0.9842,
  "message": "Synthetic spectral patterns detected. AI-generated voice signature found."
}

Error Codes:

# Step 1: Encode your audio to base64
BASE64=$(base64 -w 0 your_audio.mp3)

# Step 2: Send request
curl -X POST "https://srv99x-voice-detector-live.hf.space/detect-audio/" \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d "{\"audio_base64\": \"$BASE64\", \"audio_format\": \"mp3\", \"language\": \"en\"}"

import requests
import base64

# Encode audio
with open("your_audio.mp3", "rb") as f:
    audio_b64 = base64.b64encode(f.read()).decode("utf-8")

# Call API
response = requests.post(
    "https://srv99x-voice-detector-live.hf.space/detect-audio/",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "audio_base64": audio_b64,
        "audio_format": "mp3",
        "language": "en"
    }
)

result = response.json()
print(f"AI Generated: {result['is_ai_generated']}")
print(f"Confidence:   {result['confidence_score']:.1%}")
print(f"Message:      {result['message']}")

const audioFile = document.querySelector('input[type="file"]').files[0];
const reader = new FileReader();

reader.onload = async () => {
  const base64 = reader.result.split(',')[1];

  const response = await fetch('https://srv99x-voice-detector-live.hf.space/detect-audio/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': 'YOUR_API_KEY'
    },
    body: JSON.stringify({ audio_base64: base64, audio_format: 'mp3', language: 'en' })
  });

  const result = await response.json();
  console.log(result);
};

reader.readAsDataURL(audioFile);

• Python 3.10+
• Node.js 18+
• ffmpeg installed → Download here
• Git

# 1. Clone the repository
git clone https://github.com/Srv99x/voice-detection-ai.git
cd voice-detection-ai

# 2. Create a virtual environment
python -m venv venv

# Windows
venv\Scripts\activate

# macOS / Linux
source venv/bin/activate

# 3. Install dependencies
pip install -r requirements.txt

# 4. Create a .env file
echo "SECRET_API_KEY=your_secret_key_here" > .env

# 5. Start the server
uvicorn main:app --reload

API will be live at: http://127.0.0.1:8000
Interactive Swagger docs: http://127.0.0.1:8000/docs

# Navigate to frontend
cd frontend

# Copy env file and fill in values
cp .env.example .env
# Edit .env: set VITE_API_URL and VITE_API_KEY

# Install dependencies
npm install

# Start dev server
npm run dev

Frontend will be live at: http://localhost:5173

Backend (.env in root):

SECRET_API_KEY=your_super_secret_key_here

Frontend (frontend/.env):

VITE_API_URL=http://localhost:8000
VITE_API_KEY=your_super_secret_key_here

# Build the image
docker build -t voiceguard-ai .

# Run the container
docker run -p 7860:7860 -e SECRET_API_KEY=your_key_here voiceguard-ai

API available at http://localhost:7860

If you want to retrain the classifier on your own dataset:

voice-detection-ai/
└── dataset/
    ├── real/          ← Human voice recordings
    │   ├── english/
    │   ├── hindi/
    │   └── ...
    └── ai/            ← AI/TTS-generated audio
        ├── elevenlabs/
        ├── murf/
        └── ...

Supports .mp3, .wav, .m4a — recursive subfolder scanning

python train_model.py

The script will:

1. Load and augment all audio files (4× per file: original, noise, pitch±2)
2. Extract 1024-dim embeddings via wav2vec2-large-xlsr-53
3. Train an MLPClassifier(hidden_layers=[128, 64])
4. Save hackathon_model.pkl + model_scaler.pkl

voice-detection-ai/
│
├── 🐍 Backend
│   ├── main.py                  # FastAPI app + detection engine
│   ├── train_model.py           # ML training pipeline with augmentation
│   ├── test_api.py              # API test suite (4 test cases)
│   ├── setup_ffmpeg.py          # FFmpeg installation helper
│   ├── hackathon_model.pkl      # Trained MLP classifier (~4.3 MB)
│   ├── model_scaler.pkl         # Fitted StandardScaler (~24 KB)
│   ├── requirements.txt         # Python dependencies
│   ├── Dockerfile               # Container config (port 7860 for HF Spaces)
│   └── .github/workflows/ci.yml  # GitHub Actions CI pipeline
│
└── ⚛️ Frontend (frontend/)
    ├── src/
    │   ├── App.jsx              # Main React app (matrix rain, drag-drop, results)
    │   ├── index.css            # Full cyberpunk design system (644 lines)
    │   └── main.jsx             # React entry point
    ├── public/                  # Static assets
    ├── package.json             # Vite 7 + React 19
    ├── vite.config.js           # Vite configuration
    └── vercel.json              # SPA routing config for Vercel

The backend is deployed as a Docker Space on Hugging Face. The Dockerfile is pre-configured for the HF Spaces environment (port 7860).

To deploy your own fork:

1. Create a new Space on huggingface.co/spaces
2. Set Space SDK to Docker
3. Push this repo to your Space's git remote
4. Add SECRET_API_KEY in Space Settings → Repository secrets

Or manually:

cd frontend
npx vercel --prod

Set environment variables in the Vercel dashboard:

• VITE_API_URL → Your Hugging Face Space URL
• VITE_API_KEY → Your secret API key

• Short clips (< 2 seconds) may yield lower confidence scores
• Professional-grade voice clones with high-fidelity TTS may occasionally bypass detection
• Background noise can reduce classification reliability
• Language bias — model is strongest on English; multilingual performance depends on training data diversity
• Large audio files will increase base64 payload size and transfer time

• Streaming audio input (WebSocket API)
• Support more formats: OGG, FLAC, M4A via API
• Waveform visualizer on frontend
• History tab with past analysis results
• Confidence threshold configuration
• Batch file analysis endpoint
• Public leaderboard of tested TTS engines

Contributions are welcome and appreciated!

# Fork the repo, then:
git checkout -b feature/your-amazing-feature
git commit -m "feat: add your amazing feature"
git push origin feature/your-amazing-feature
# Open a Pull Request!

Please read CONTRIBUTING.md before submitting changes.

Good first issues to tackle:

• Improve model accuracy with larger/more diverse datasets
• Add real waveform visualization using Web Audio API
• Add OGG/FLAC/M4A support to the API
• Write more comprehensive unit tests
• Add dark/light mode toggle to frontend

This project is licensed under the MIT License — see the LICENSE file for details.

Built with 🧠 neural networks, ☕ caffeine, and ❤️ for AI transparency.

If this project helped you, please consider giving it a ⭐ — it really means a lot!