# Claude Video Whisper API Preference: Why Groq Wins Over OpenAI

> Discover why Claude Video prefers the Groq Whisper API over OpenAI for faster and cheaper transcriptions. Learn about automatic selection and fallback options.

- Repository: [bradautomates/claude-video](https://github.com/bradautomates/claude-video)
- Tags: comparison
- Published: 2026-07-28

---

**Claude Video prefers the Groq Whisper API by default, automatically selecting Groq's whisper-large-v3 model for faster, cheaper transcription while only falling back to OpenAI's whisper-1 when explicitly forced or when no Groq API key is present.**

Claude Video is an open-source video analysis tool that transcribes audio using external Whisper APIs. According to the source code in the `bradautomates/claude-video` repository, the application implements a strict hierarchy for its **Claude Video Whisper API** integration that prioritizes cost-effectiveness and speed.

## Why Groq is the Preferred Backend

The developers explicitly designed Claude Video to prioritize **Groq** as the default transcription service. In [`skills/watch/scripts/setup.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/setup.py), the installation script notes that *"Groq is preferred: it runs whisper-large-v3 at a fraction of OpenAI's price"*.

This preference is reinforced in the user-facing documentation at [`skills/watch/SKILL.md`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/SKILL.md), which states that the default backend is Groq (`whisper-large-v3`) because it is cheaper and faster than alternatives. OpenAI's `whisper-1` serves strictly as a fallback mechanism when Groq credentials are absent or when users manually override the configuration.

## Backend Resolution Logic in watch.py

The backend selection logic resides in [`skills/watch/scripts/watch.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/watch.py). When processing a video file, the application calls `load_api_key(args.whisper)` to determine which provider to use.

```python
backend, api_key = load_api_key(args.whisper)          # selects Groq when both keys exist

...
response = _post_whisper(GROQ_ENDPOINT, api_key, GROQ_MODEL, audio_path)   # Groq path

response = _post_whisper(OPENAI_ENDPOINT, api_key, OPENAI_MODEL, audio_path)   # OpenAI path

```

The `load_api_key` function automatically returns Groq credentials when both `GROQ_API_KEY` and `OPENAI_API_KEY` environment variables are present. This ensures that **Groq receives priority** without requiring explicit user intervention.

## CLI Options for Forcing a Specific Provider

Users can override the default **Claude Video Whisper API** selection using command-line flags. The `--whisper` argument accepts specific values to force a particular backend or disable transcription entirely.

```bash

# Automatic (preferred) selection – uses Groq if a GROQ_API_KEY is present,

# otherwise falls back to OpenAI if an OPENAI_API_KEY is present.

watch video.mp4

# Force the Groq backend explicitly

watch video.mp4 --whisper groq

# Force the OpenAI backend explicitly

watch video.mp4 --whisper openai

# Disable Whisper entirely (frames-only mode)

watch video.mp4 --no-whisper

```

When you explicitly specify `--whisper openai`, the application bypasses the Groq preference logic and routes requests directly to OpenAI's `whisper-1` endpoint.

## Model Specifications and Constants

The specific model versions are defined in [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py). Groq utilizes the `whisper-large-v3` model, while OpenAI uses the standard `whisper-1` model.

- **Groq**: `whisper-large-v3` via `GROQ_ENDPOINT`
- **OpenAI**: `whisper-1` via `OPENAI_ENDPOINT`

These constants feed into the `_post_whisper` function, which handles the HTTP POST requests to the respective API endpoints using the resolved API key.

## Summary

- **Claude Video Whisper API** integration prioritizes Groq over OpenAI by default.
- The selection logic in [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) automatically chooses Groq when both API keys are available.
- Groq provides access to `whisper-large-v3` at lower cost and higher speed than OpenAI's `whisper-1`.
- Users can force OpenAI using `--whisper openai` or disable audio processing with `--no-whisper`.
- Fallback to OpenAI occurs only when no Groq key exists or when explicitly requested.

## Frequently Asked Questions

### Which Whisper API does Claude Video use by default?

Claude Video uses the **Groq Whisper API** by default. When both `GROQ_API_KEY` and `OPENAI_API_KEY` environment variables are present, the `load_api_key` function in [`watch.py`](https://github.com/bradautomates/claude-video/blob/main/watch.py) automatically selects Groq's `whisper-large-v3` model.

### How do I force Claude Video to use OpenAI instead of Groq?

Pass the `--whisper openai` flag when running the watch command. This bypasses the automatic preference logic and routes transcription requests to OpenAI's `whisper-1` endpoint instead of Groq.

### What Whisper models does Claude Video support?

According to [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py), Claude Video supports **whisper-large-v3** via Groq and **whisper-1** via OpenAI. These model constants are hardcoded in the source and passed to the respective API endpoints.

### Why does Claude Video prefer Groq over OpenAI for transcription?

The developers chose Groq as the preferred backend because it runs the `whisper-large-v3` model at a fraction of OpenAI's price while delivering faster inference speeds. This cost-performance advantage is documented in both [`setup.py`](https://github.com/bradautomates/claude-video/blob/main/setup.py) and [`SKILL.md`](https://github.com/bradautomates/claude-video/blob/main/SKILL.md).