> ## Documentation Index
> Fetch the complete documentation index at: https://veniceai-mintlify-de47a659.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Speech-to-Text

> Trascrivi file audio in testo con i modelli speech-to-text di Venice via /audio/transcriptions, scegliendo formati di risposta e timestamp dei segmenti.

Lo speech-to-text trascrive l'audio parlato in testo scritto. Invia un file audio a `/audio/transcriptions`, scegli un modello di trascrizione e seleziona il formato di risposta desiderato.

Stai lavorando con la registrazione di una conversazione? [Note di riunione con lo speech-to-text](/guides/media/meeting-notes) parte da un file audio e arriva a decisioni e azioni da fare che citano il secondo in cui sono state concordate, spiegando anche quali modelli restituiscono i timing dei segmenti e come gestire una trascrizione che non dice mai chi sta parlando.

## Utilizzo di Base

<CodeGroup>
  ```python Python theme={null}
  import os

  import requests

  with open("meeting.mp3", "rb") as audio:
      response = requests.post(
          "https://api.venice.ai/api/v1/audio/transcriptions",
          headers={"Authorization": f"Bearer {os.environ['VENICE_API_KEY']}"},
          files={"file": audio},
          data={
              "model": "nvidia/parakeet-tdt-0.6b-v3",
              "response_format": "json",
          },
      )

  response.raise_for_status()
  print(response.json()["text"])
  ```

  ```javascript Node.js theme={null}
  import { createReadStream } from "node:fs";
  import FormData from "form-data";

  const form = new FormData();
  form.append("file", createReadStream("meeting.mp3"));
  form.append("model", "nvidia/parakeet-tdt-0.6b-v3");
  form.append("response_format", "json");

  const response = await fetch("https://api.venice.ai/api/v1/audio/transcriptions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.VENICE_API_KEY}`,
      ...form.getHeaders(),
    },
    body: form,
  });

  if (!response.ok) {
    throw new Error(await response.text());
  }

  const transcript = await response.json();
  console.log(transcript.text);
  ```

  ```bash cURL theme={null}
  curl https://api.venice.ai/api/v1/audio/transcriptions \
    -H "Authorization: Bearer $VENICE_API_KEY" \
    --form file=@meeting.mp3 \
    --form model=nvidia/parakeet-tdt-0.6b-v3 \
    --form response_format=json
  ```
</CodeGroup>

## Input Supportati

I formati audio supportati sono `wav`, `wave`, `flac`, `m4a`, `aac`, `mp4`, `mp3`, `ogg`, `oga` e `webm`. Un file è accettato quando il suo MIME type o la sua estensione è in quella lista, e i byte caricati devono anche superare un controllo dei magic byte — rinominare un file con un'estensione supportata non lo farà passare. Consulta la pagina [Modelli Speech-to-Text](/models/speech-to-text) per il supporto dei modelli e i prezzi aggiornati.

## Formati di Risposta

| Formato | Da usare quando                                                                          |
| ------- | ---------------------------------------------------------------------------------------- |
| `json`  | Vuoi una risposta strutturata: `text`, più `duration` e `timestamps` quando disponibili. |
| `text`  | Vuoi testo semplice senza fare parsing di JSON.                                          |

<Note>
  Questi sono gli unici due valori accettati da `response_format`. Non esistono le opzioni `srt`, `vtt` o `verbose_json` — richiederne una restituisce un `400`. Per costruire sottotitoli, usa `timestamps: true` con `response_format: json` e renderizza tu stesso i dati di timing.
</Note>

## Timestamps

Passa `timestamps=true` per ricevere i dati di timing insieme alla trascrizione. Il supporto è specifico per modello e la granularità varia:

| Modello                       | Granularità |
| ----------------------------- | ----------- |
| `elevenlabs/scribe-v2`        | `word`      |
| `stt-xai-v1`                  | `word`      |
| `openai/whisper-large-v3`     | `segment`   |
| `fal-ai/wizper`               | `segment`   |
| `nvidia/parakeet-tdt-0.6b-v3` | Nessuna     |

<Warning>
  Il modello predefinito, `nvidia/parakeet-tdt-0.6b-v3`, accetta `timestamps=true` e poi lo ignora — ottieni una risposta contenente solo `text`, senza errori né avvisi. Scegli un modello dalla tabella qui sopra se hai bisogno dei timing e verifica che la chiave `timestamps` esista prima di leggerla.
</Warning>

```bash theme={null}
curl https://api.venice.ai/api/v1/audio/transcriptions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  --form file=@meeting.mp3 \
  --form model=elevenlabs/scribe-v2 \
  --form timestamps=true \
  --form response_format=json
```

```json theme={null}
{
  "text": "The quick brown fox jumps over the lazy dog.",
  "duration": 4.099,
  "timestamps": {
    "word": [
      { "word": "The", "start": 0.0, "end": 0.14 },
      { "word": "quick", "start": 0.14, "end": 0.42 }
    ]
  }
}
```

I modelli a livello di segmento restituiscono invece un array `segment`, in cui ogni voce è `{ "text": "...", "start": 0.0, "end": 3.2 }`. Tutti i tempi sono in secondi.

<Note>
  Nessun modello di trascrizione di Venice esegue la diarizzazione dei parlanti, quindi non esiste un campo `speaker` in alcuna risposta. Una trascrizione è un unico flusso di testo — i parlanti possono essere attribuiti solo quando un nome viene pronunciato ad alta voce.
</Note>

## Consigli per la Produzione

* Mantieni l'audio chiaro ed evita, se possibile, la sovrapposizione tra parlanti.
* Suddividi registrazioni molto lunghe in chunk più piccoli se il tuo flusso richiede minore latenza o retry più semplici.
* Memorizza il percorso audio originale, l'ID del modello e il formato di risposta insieme a ogni trascrizione per esigenze di tracciabilità.

## Risorse Correlate

* [API Audio Transcriptions](/api-reference/endpoint/audio/transcriptions)
* [Modelli Speech-to-Text](/models/speech-to-text)
* [Guida al Text-to-Speech](/guides/media/text-to-speech)