# Why Groq whisper-large-v3 Is Preferred Over OpenAI whisper-1 in the claude-video Skill

> Discover why Groq whisper-large-v3 outperforms OpenAI whisper-1 in the claude-video skill. Enjoy lower costs, faster inference, and Python-only operation for efficient speech-to-text.

- Repository: [bradautomates/claude-video](https://github.com/bradautomates/claude-video)
- Tags: deep-dive
- Published: 2026-08-08

---

**The claude-video skill defaults to Groq's whisper-large-v3 model because it delivers substantially lower costs and faster inference than OpenAI's whisper-1 while operating entirely within Python's standard library, eliminating external SDK dependencies.**

The **bradautomates/claude-video** repository implements a video analysis skill designed to run across multiple AI coding environments including Claude Code, Codex, and Cursor. When transcribing audio content from videos, the system relies on external Whisper ASR services, yet the codebase deliberately prioritizes **Groq whisper-large-v3** over OpenAI's equivalent for three architectural reasons tied to performance, cost, and deployment simplicity.

## Cost and Inference Speed Advantages

Groq's inference infrastructure provides dramatically lower pricing and reduced latency for the same model architecture compared to OpenAI's hosted solution. According to the project documentation in [`README.md`](https://github.com/bradautomates/claude-video/blob/main/README.md), the Groq endpoint is explicitly designated as the *"preferred default: cheaper, fast"* at line 171. This cost-benefit analysis is reinforced in [`skills/watch/SKILL.md`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/SKILL.md) at line 227, which reiterates that the Groq API serves as the *"preferred default: cheaper, faster"* backend for transcription tasks.

These performance characteristics make Groq particularly suitable for processing long-form video content where transcription costs accumulate linearly with audio duration.

## Pure Standard Library Implementation

The transcription module avoids third-party SDKs entirely, communicating directly with service endpoints using only `urllib.request` from Python's standard library. As noted in the source comment at [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py) line 9, the implementation maintains a *"Pure stdlib — no `pip install groq` or `pip install openai` needed"* architecture.

This design choice ensures the skill remains lightweight and deployable in restricted environments where package installation permissions are limited. By handling HTTP requests natively rather than relying on official client libraries, the system reduces dependency surface area and avoids version conflicts between SDKs.

## Automatic Backend Prioritization

When both `GROQ_API_KEY` and `OPENAI_API_KEY` environment variables are present, the codebase automatically selects Groq as the primary backend. The selection logic in [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py) at line 68 implements a priority system where, as the comment states, *"If `preferred` is 'groq' or 'openai', only that backend's key is considered."*

The [`setup.py`](https://github.com/bradautomates/claude-video/blob/main/setup.py) installation script at line 346 further reinforces this hierarchy by presenting the Groq API key as the preferred authentication method during configuration. This default behavior ensures users benefit from the cost and speed advantages without manual intervention, while OpenAI's whisper-1 remains accessible as a fallback via explicit configuration.

## Implementation Architecture

The backend selection mechanism centers on the `candidates` tuple defined in [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py) at line 98, which maps environment variables to their respective service endpoints. The `--backend` command-line flag parsed at line 405 allows runtime override of the default preference, enabling explicit selection of either service when both credentials are available.

Key files implementing this preference logic include:

- **[`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py)** – Core transcription module that routes requests to Groq by default using standard library HTTP clients
- **[`skills/watch/scripts/watch.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/watch.py)** – Orchestration script exposing the `--whisper` option for backend selection
- **[`skills/watch/scripts/setup.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/setup.py)** – Installation helper that prioritizes Groq API key configuration at line 346
- **[`skills/watch/SKILL.md`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/SKILL.md)** – User documentation specifying Groq as the default transcription service

## Usage Examples

To leverage the default Groq backend, set only the Groq API key:

```bash
export GROQ_API_KEY=sg_XXXXXXXXXXXXXXXXXXXXXXXX
/claude watch https://www.youtube.com/watch?v=example

```

To force OpenAI's whisper-1 instead, explicitly specify the backend:

```bash
export OPENAI_API_KEY=sk-XXXXXXXXXXXXXXXXXXXXXXXX
/claude watch https://www.youtube.com/watch?v=example --whisper openai

```

For direct script invocation without the skill wrapper:

```bash
python -m skills.watch.scripts.whisper path/to/video.mp4 --backend groq
python -m skills.watch.scripts.whisper path/to/video.mp4 --backend openai

```

## Summary

- **Groq whisper-large-v3** is the default transcription backend in claude-video due to superior cost efficiency and inference speed compared to OpenAI whisper-1.
- The implementation uses **Python's standard library** exclusively, avoiding dependencies on the Groq or OpenAI SDKs through direct HTTP API calls in [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py).
- When both API keys are present, the system **automatically prioritizes Groq** unless explicitly overridden with the `--whisper openai` or `--backend openai` flags.
- The architecture supports seamless fallback to OpenAI while maintaining a lightweight, portable codebase suitable for restricted execution environments.

## Frequently Asked Questions

### Can I use OpenAI whisper-1 instead of Groq whisper-large-v3?

Yes. While Groq is the default, you can force OpenAI's whisper-1 by setting the `OPENAI_API_KEY` environment variable and passing the `--whisper openai` flag to the watch command, or using `--backend openai` when calling the whisper.py script directly.

### Do I need to install the Groq SDK to use this skill?

No. The [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py) module implements a pure standard library approach using `urllib.request` to communicate with the Groq HTTP endpoint. No `pip install groq` or `pip install openai` commands are required, keeping the skill dependency-free.

### Is Groq's whisper-large-v3 cheaper than OpenAI's whisper-1?

According to the claude-video documentation at [`README.md`](https://github.com/bradautomates/claude-video/blob/main/README.md) line 171 and [`SKILL.md`](https://github.com/bradautomates/claude-video/blob/main/SKILL.md) line 227, Groq is explicitly described as the *"preferred default: cheaper, faster"* option, indicating significant cost savings over OpenAI's hosted whisper-1 service for equivalent transcription workloads.

### How does the skill handle multiple API keys?

When both `GROQ_API_KEY` and `OPENAI_API_KEY` are detected, the backend selection logic in [`skills/watch/scripts/whisper.py`](https://github.com/bradautomates/claude-video/blob/main/skills/watch/scripts/whisper.py) treats Groq as the preferred provider. The code at line 68 implements a priority check that defaults to Groq unless specifically instructed otherwise through command-line flags.