# Tre tool per gli effetti sonori dei video con Claude Code

Guida di Riccardo Belli, dati letti il 5 novembre 2026.
Pagina: https://www.riccardobelli.com/suoni/

Il giro: Openverse trova i suoni, Real SFX li mette sul fotogramma giusto, Earshot crea quelli che mancano e fa ascoltare a Claude quello che ha messo.

## 1. Openverse, l'archivio

- Sito: https://openverse.org
- Repo: https://github.com/WordPress/openverse (518 stelle, licenza MIT)
- 5.223.435 audio con licenza aperta: 3.986.828 da Wikimedia Commons, 644.709 brani da Jamendo, 591.898 suoni da Freesound. Per gli effetti sonori la fonte è Freesound.
- API pubblica senza chiave: 20 richieste al minuto e 200 al giorno. Con la registrazione i limiti salgono un po'.
- Licenze: ci sono anche le CC BY-NC, che vietano l'uso commerciale. Per un video di lavoro tieni solo CC0 e CC BY. Le CC BY vanno citate. Openverse scrive nei termini che non verifica le licenze: il controllo finale resta a te.

Prompt per Claude Code:

```
Mi servono effetti sonori per il video di questa cartella. Cercali su Openverse con la sua API pubblica, senza chiave, usando curl:
https://api.openverse.org/v1/audio/?q=PAROLA&source=freesound&license=cc0,by&page_size=20

Parole da cercare: [whoosh], [click], [pop], [impact], [riser].
Per ogni parola scarica i 3 risultati più corti (il campo duration è in millisecondi) in sfx/PAROLA/, dal campo url.
Scrivi in sfx/CREDITI.md titolo, autore, licenza e link (campo foreign_landing_url) di ogni file. Per i CC BY copia anche il campo attribution: va nella descrizione del video.
Resta sotto le 20 richieste al minuto.
```

## 2. Real SFX, la skill che piazza i suoni

- Repo: https://github.com/Clipwing/skills/tree/main/skills/real-sfx
- Skill per Claude Code: guarda il montaggio, trova i momenti che vogliono un suono, li mette sul fotogramma esatto al livello dei suoni che c'erano, tiene musica e voce. Restituisce un MP4 nuovo e la traccia degli effetti in WAV.
- Script MIT. Dentro ci sono solo 78 suoni d'interfaccia CC0: per il resto vuole una libreria tua (va bene la cartella sfx/ di Openverse).
- Claude non sente: la skill sceglie da misure e spettrogrammi e alla fine ti dice i cinque punti da ascoltare.
- Serve Python 3.9 o più recente e FFmpeg (su Mac ffmpeg-full).

Mac:

```
git clone https://github.com/Clipwing/skills.git clipwing-skills
mkdir -p ~/.claude/skills
cp -R clipwing-skills/skills/real-sfx ~/.claude/skills/
brew install ffmpeg-full
export PATH="$(brew --prefix ffmpeg-full)/bin:$PATH"
```

Windows (PowerShell):

```
git clone https://github.com/Clipwing/skills.git clipwing-skills
New-Item -ItemType Directory -Force "$HOME\.claude\skills" | Out-Null
Copy-Item -Recurse "clipwing-skills\skills\real-sfx" "$HOME\.claude\skills\"
winget install Python.Python.3.12
winget install Gyan.FFmpeg
```

Riavvia Claude Code, poi:

```
Usa la skill real-sfx.
Prima configurala: come libreria principale usa la cartella [sfx/] con i suoni scaricati da Openverse e aggiungi i 78 suoni d'interfaccia (uisfx). Controlla che sia tutto a posto con setup.py check.
Poi fai il sound design di [render.mp4]: trova i momenti che vogliono un suono, tieni voce e musica, dammi il nuovo MP4 con la traccia degli effetti separata.
Alla fine dimmi i cinque punti che devo ascoltare io.
```

## 3. Earshot, le orecchie di Claude Code

- Repo: https://github.com/Leonxlnx/earshot (3.963 stelle, licenza MIT, versione 0.4.0)
- Descrive un suono a parole, dice quanto somiglia a quello che cerchi, trova il punto migliore in una registrazione lunga, controlla il sincrono con gli stacchi.
- `earshot forge` crea un suono da zero in codice e lo migliora ascoltandolo. `earshot kit` costruisce il kit di suoni di un video intero. Banca di 252 suoni fatti in codice.
- Gira in locale sul processore, senza GPU. Al primo uso scarica due modelli aperti, circa 1,1 GB.
- Serve Python 3.10 o più recente e FFmpeg.

Installazione (Mac e Linux):

```
git clone https://github.com/Leonxlnx/earshot && cd earshot
python3 -m venv .venv
.venv/bin/python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
.venv/bin/python -m pip install -e ".[mcp,llm,dev]"
.venv/bin/python -m earshot doctor --load
```

Server MCP e skill, dalla cartella earshot:

```
claude mcp add earshot --scope user -e EARSHOT_THREADS=3 -- "$(pwd)/.venv/bin/python" -m earshot mcp
mkdir -p ~/.claude/skills
cp -R skills/earshot skills/real-sound ~/.claude/skills/
```

Su Windows il Python è `.venv\Scripts\python`. Su un computer lento avvia Claude Code con `MCP_TIMEOUT=60000`.

Prompt 1, il kit del video:

```
Usa earshot. Crea il kit di suoni per [video.mp4] con il preset launch, prendendo un suono per ruolo dalla banca di earshot.
Metti ogni suono sugli stacchi e sulle animazioni del video, poi controlla con earshot critique che cadano in sincrono.
Dammi il video con i suoni e l'elenco di cosa hai messo e in che secondo.
```

Prompt 2, un suono che non c'è:

```
Con earshot forge crea un whoosh veloce e secco per lo stacco a [00:04] di [video.mp4], in 4 varianti.
Confrontale con earshot match sulla descrizione "a fast crisp air whoosh" e tieni la migliore.
```

Prompt 3, il controllo:

```
Ascolta con earshot i suoni del video [film_sfx.mp4]: fammi la timeline e dimmi dove un suono arriva in ritardo rispetto allo stacco o copre la voce.
```

## L'ordine

1. Scarica i primi suoni da Openverse con il prompt, solo CC0 e CC BY.
2. Installa Real SFX e dagli quella cartella come libreria.
3. Fai il sound design del tuo render e ascolta i cinque punti che ti segnala.
4. Aggiungi Earshot per i suoni che mancano e per far controllare a Claude il sincrono.
5. Tieni il file dei crediti: le CC BY vanno citate nella descrizione del video.
