Source: https://ailoot.ai/models/it/openai-gpt-4o-transcribe-diarize/
Canonical: https://ailoot.ai/models/it/openai-gpt-4o-transcribe-diarize/
Language: it

# gpt-4o-transcribe-diarize

[Markdown](https://ailoot.ai/models/it/openai-gpt-4o-transcribe-diarize/index.md) · [JSON](https://ailoot.ai/models/it/openai-gpt-4o-transcribe-diarize/facts.json)

## [gpt-4o-transcribe-diarize](https://ailoot.ai/models/it/openai-gpt-4o-transcribe-diarize/)

GPT-4o Transcribe Diarize converte la voce registrata in testo con segmenti identificati per parlante e riferimenti temporali. È adatto a riunioni, interviste e registrazioni con più persone in cui la trascrizione deve mostrare chi ha parlato e quando, con brevi riferimenti vocali facoltativi per i parlanti noti.

- [**Ailoot Ultra · Riconoscimento vocale** `POST /v1/audio/transcriptions` `openai/gpt-4o-transcribe-diarize`](https://ailoot.ai/models/it/openai-gpt-4o-transcribe-diarize/#method-0)

Informazioni sul modello

Questa descrizione illustra le funzionalità del modello. Gli input, gli output e le opzioni disponibili in Ailoot per il metodo selezionato sono elencati di seguito.

GPT-4o Transcribe Diarize è il modello di riconoscimento automatico della voce di OpenAI con diarizzazione dei parlanti integrata. Associa i segmenti audio trascritti ai diversi parlanti di una conversazione. Il risultato utile è una trascrizione organizzata per parlante e tempo, anziché un semplice blocco continuo di parole. È destinato alla voce registrata che richiede etichette dei parlanti, come una riunione, un’intervista o una discussione con più persone.

#### Preparare la registrazione completata

Fornite la registrazione da trascrivere. Il processo documentato per i file accetta MP3, MP4, MPEG, MPGA, M4A, WAV e WebM, con un limite di dimensione del file di 25 MB. Conservate la registrazione di origine, affinché un turno di parola, un nome o una frase poco chiara possa essere verificato rispetto all’audio effettivo.

Per una riunione, conservate la sequenza della conversazione anziché eliminare le pause brevi che aiutano a distinguere i turni. Per un’intervista, mantenete domanda e risposta insieme quando l’attività richiede la loro relazione. La preparazione dell’audio deve rendere udibile la voce senza rimuovere informazioni importanti per il risultato identificato per parlante.

È un processo di trascrizione di file. Elaborare una registrazione completata e riconoscere un flusso audio ancora in arrivo sono attività diverse; l’identificazione dei parlanti del modello non è supportata nelle sessioni di trascrizione Realtime.

#### Richiedere una trascrizione identificata per parlante

Il formato del risultato `diarized_json` restituisce segmenti con etichette di identità dei parlanti e tempi di inizio e fine. Ogni segmento contiene anche il proprio testo trascritto. Conservate questi campi insieme, affinché le parole possano essere collegate alla parte pertinente della registrazione.

Per una trascrizione utile di una riunione, conservate la sequenza dei segmenti e mostrate le parole di ciascun parlante con i relativi tempi. Un’attività successiva può usare quella trascrizione per preparare un verbale o azioni da svolgere, ma la diarizzazione stessa non stabilisce ciò che la riunione ha deciso e non genera un riepilogo verificato.

Le etichette dei parlanti descrivono il raggruppamento della voce effettuato dal modello. Esaminate le transizioni in cui le persone si interrompono, parlano brevemente o contemporaneamente. Un risultato ben strutturato è utile per navigare e verificare, mentre un’attribuzione specifica può comunque richiedere l’ascolto dell’audio originale.

#### Riferimenti di parlanti noti

Il processo documentato può accettare fino a quattro riferimenti di parlanti con nome. Ogni riferimento è una breve clip audio di 2–10 secondi in un formato supportato per il caricamento principale. I nomi e i riferimenti vengono forniti insieme, affinché i segmenti possano essere associati a parlanti noti.

Preparate un riferimento che contenga chiaramente il parlante desiderato e mantenetene il nome coerente con le etichette previste per la trascrizione. Per un’intervista, un riferimento per chi la conduce può aiutare a organizzare il risultato identificato per parlante senza trasformare ogni partecipante in un’etichetta anonima. Il riferimento è un input per l’attribuzione; non è un’operazione generale di clonazione della voce né una prova dell’identità di una persona.

Non confondete il dare un nome a un parlante con il modificare le parole pronunciate. L’output utile deve comunque preservare il contenuto della registrazione e l’ordine effettivo dei turni.

#### Suddivisione e limiti del modello

Per audio di durata superiore a 30 secondi, il produttore richiede una strategia di suddivisione, automatica oppure con una configurazione di rilevamento dell’attività vocale. Questo requisito non è una durata massima di registrazione. Descrive come l’input più lungo viene suddiviso per l’elaborazione.

La scheda del modello indica una finestra di contesto di 16 000 token e un massimo di 2 000 token di output. Sono limiti di token del modello, distinti dal limite di caricamento di 25 MB del processo per file e dalla soglia di suddivisione. Non vanno convertiti in un numero inventato di minuti valido per ogni registrazione.

Conservate i riferimenti temporali e l’identità dei segmenti quando assemblate o esaminate una trascrizione più lunga. Se una registrazione è stata suddivisa prima dell’invio, mantenete la relazione di ciascuna parte con l’audio originale, affinché un tempo locale non venga confuso con la sua posizione nella conversazione completa.

#### Trasmettere in streaming i segmenti finalizzati

Il processo di trascrizione di file può trasmettere il testo in streaming mentre la registrazione viene elaborata. Con lo streaming identificato per parlante, i segmenti completati producono eventi di segmento. Gli incrementi di testo includono un identificatore del segmento, ma non contengono assegnazioni parziali dei parlanti; un parlante viene assegnato quando il segmento è finalizzato.

Questa distinzione è importante per la presentazione. Mostrate il testo provvisorio e un turno di parola finalizzato come stati diversi, anziché attribuire un’etichetta incerta di parlante prima che il modello abbia completato il segmento. Conservate il risultato completato quando la trascrizione serve per modifiche o analisi successive.

#### Limiti del modello e dell’output

Questo profilo è il modello di diarizzazione, distinto dalla trascrizione GPT-4o ordinaria, dalla trascrizione Mini, dalla sintesi vocale e dai modelli di conversazione dal vivo. Non supporta prompt di trascrizione; mantenete eventuali revisioni o correzioni terminologiche come passaggi separati da verificare rispetto all’audio originale. L’interfaccia del produttore trascrive audio registrato in testo. Non genera una risposta audio e non traduce una registrazione attraverso il processo separato di traduzione audio.

Usatelo per trascrizioni che richiedono sia contenuto sia struttura dei parlanti. Verificate nomi, termini tecnici, numeri, confini dei turni e attribuzioni rispetto alla registrazione. Conservate l’audio, il formato del risultato scelto, i riferimenti e la trascrizione completata, affinché una correzione possa riguardare una frase concreta o un’assegnazione di parlante.

**Ailoot Ultra · Riconoscimento vocale** `POST /v1/audio/transcriptions` `openai/gpt-4o-transcribe-diarize`

[`openai/gpt-4o-transcribe-diarize`](https://ailoot.ai/models/it/#m=openai%2Fgpt-4o-transcribe-diarize&route=Ultra&caller=openai%2Fgpt-4o-transcribe-diarize&fmt=transcriptions)

OpenAI /`openai/gpt-4o-transcribe-diarize`

### Introduzione

GPT-4o Transcribe Diarize converte la voce registrata in testo con segmenti identificati per parlante e riferimenti temporali. È adatto a riunioni, interviste e registrazioni con più persone in cui la trascrizione deve mostrare chi ha parlato e quando, con brevi riferimenti vocali facoltativi per i parlanti noti.

Input accettati

Audio

Risultati

transcription

### Disponibile in Ailoot · input e metodi

**Ailoot Ultra · Riconoscimento vocale** `POST /v1/audio/transcriptions`

Tipi di input

`audio`

Tipi di output

`transcription`

Formato di output

json

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti openai/gpt-4o-transcribe-diarize | Predefinito— |
| Campo`file` | Tipo`file` | RequisitoObbligatorio | Valori e limiti Numero massimo di byte: 26.214.400 Tipi MIME: audio/mpeg Estensione del file: .mp3 Durata massima, secondi: 30 | Predefinito— |
| Campo`response_format` | Tipo`string` | RequisitoObbligatorio | Valori e limiti diarized\_json | Predefinito— |

Combinazioni di materiali in input

**diarized\_transcription**

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`content_type` | Contrattomultipart/form-data |
| Parametro`required` | Contrattomodel, file, response\_format |
| Parametro`file_formats` | Contrattomp3 |
| Parametro`max_audio_seconds` | Contratto30 |
| Parametro`max_bytes` | Contratto26214400 |
| Parametro`response_format` | Contrattodiarized\_json |
| Parametro`other_options` | Contrattofalse |
| Parametro`material_types` | Contrattoaudio |
| Parametro`additional_properties` | Contrattofalse |
| Parametro`form_string_maximum_bytes` | Contratto256 |

Alias del metodo: `/audio/transcriptions`

Ciclo di vita: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · task\_id effettivamente restituito o record della libreria multimediale

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

Usa la registrazione reale e il formato corrispondente.

Conserva la trascrizione completa, i segmenti, gli ID dei parlanti e i tempi.

### Tariffe

Le tariffe non aggiungono opzioni alla richiesta. I parametri supportati sono elencati nel metodo selezionato.

Modalità rapida

Non specificato Quando è selezionata la modalità rapida

Modalità flex

Non specificato Quando è selezionata la modalità flex

Sforzo massimo di ragionamento

Non specificato Quando lo sforzo massimo di ragionamento usa l'adeguamento predefinito (default)

#### Tariffe Ailoot

#### Prezzi per configurazione

Associa ogni costo alle condizioni indicate. Usa una sola tariffa per ogni insieme di configurazioni alternative.

| Configurazione | Listino delle tariffe | Unità di fatturazione | Costo |
| --- | --- | --- | --- |
| ConfigurazioneTariffe base dei token | Listino delle tariffeTariffa base | Unità di fatturazione— | Costo Input · Token in input **—** / 1K token Output · Token in output **—** / 1K token Input · Lettura dalla cache **—** / 1K token Input · Scrittura nella cache **—** / 1K token Input · Scrittura nella cache, 1 ora **—** / 1K token |
| ConfigurazioneUltra | Listino delle tariffe— | Unità di fatturazione/ 1K token audio | Costo Input · token audio in ingresso **$0.012** / 1K token audio |
| ConfigurazioneUltra | Listino delle tariffe— | Unità di fatturazione/ 1K token audio | Costo Output · token audio in uscita **$0.02** / 1K token audio |

Ailoot prenota un importo stimato prima di una richiesta. Dopo il risultato, addebita il costo finale in base all’utilizzo misurato. Per lo streaming, l’addebito usa il record finale di utilizzo. [Come funzionano la prenotazione e l’addebito finale →](https://ailoot.ai/docs/it/billing/reserve/)

### Esempi di richieste

#### Ailoot Ultra · Riconoscimento vocale

curl · creazione con la richiesta conservata invariata

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_AUDIO_FILE:?Set the path to your actual MP3 recording}"
export AILOOT_AUDIO_FILE
python3 - <<'PY_REQUEST'
import os
from pathlib import Path
p=Path(os.environ["AILOOT_AUDIO_FILE"])
if not p.is_file() or p.suffix.lower()!=".mp3":raise SystemExit("Choose an existing MP3 recording")
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/audio/transcriptions \
  -H "Authorization: Bearer $AILOOT_API_KEY" \
  --form-string model=openai/gpt-4o-transcribe-diarize -F "file=@$AILOOT_AUDIO_FILE" --form-string response_format=diarized_json \
  -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text())))
PY_RESULT
```

### Ricevi e salva i risultati

#### Ailoot Ultra · Riconoscimento vocale

json

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

Altre letture di contenuto

Salva ogni trascrizione restituita di tua proprietàLibreria multimedialeStato dell’attivitàDettagli delle risorse

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
export AILOOT_API_KEY
python3 - <<'PY_ASSETS'
import json,os,subprocess
from pathlib import Path
from urllib.parse import urljoin,urlsplit
r=json.loads(Path('result.json').read_text())
urls=[]
if isinstance(r.get('asset_url'),str) and r['asset_url']:urls.append(('transcript',r['asset_url']))
for label,path in urls:
    u=urljoin('https://api.ailoot.ai',path);z=urlsplit(u)
    if z.scheme!='https' or z.netloc!='api.ailoot.ai' or z.username or z.password:raise SystemExit('Use the actual returned Ailoot owned content URL')
    target=Path('owned-'+label+'.bin')
    subprocess.run(['curl','--fail-with-body','--silent','--show-error',u,'-H','Authorization: Bearer '+os.environ['AILOOT_API_KEY'],'-D',str(target)+'.headers','-o',str(target)],check=True)
print('All returned owned URLs saved; complete metadata, timing and usage remain in the JSON.')
PY_ASSETS
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/media/assets \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o media-assets.json
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_MEDIA_TASK_ID:?Set the actual ID returned by the response or media-library metadata}"
export AILOOT_MEDIA_TASK_ID
resource_id=$(python3 -c 'import os,urllib.parse;print(urllib.parse.quote(os.environ["AILOOT_MEDIA_TASK_ID"],safe=""))')
curl --fail-with-body --silent --show-error "https://api.ailoot.ai/v1/media/tasks/$resource_id" \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o media-task.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("media-task.json").read_text())))
PY_RESULT
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_ASSET_ID:?Set the actual ID returned by the response or media-library metadata}"
export AILOOT_ASSET_ID
resource_id=$(python3 -c 'import os,urllib.parse;print(urllib.parse.quote(os.environ["AILOOT_ASSET_ID"],safe=""))')
curl --fail-with-body --silent --show-error "https://api.ailoot.ai/v1/media/assets/$resource_id" \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o media-asset.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("media-asset.json").read_text())))
PY_RESULT
```

##### Conserva tutti i risultati completati

Conserva ogni risposta, file e parte di contenuto restituiti per intero.

Conserva il JSON completo, non solo il testo; preserva ogni segmento, parlante e timestamp disponibile e l'identità effettiva dell'attività o della risorsa.

##### Se occorre verificare la risposta originale

Conserva operation\_id/X-Client-Request-ID originale per la riconciliazione senza reinvio; non esiste una rotta dedicata al polling audio.

Campi della risposta

| Campo | Tipo |
| --- | --- |
| Campo`text` | Tipostring |
| Campo`segments[]` | Tipoobject |
| Campo`task_id` | Tipostring |
| Campo`asset_url` | Tipostring |
| Campo`usage` | Tipoobject |
| Campo`segments[].speaker` | Tipostring |
| Campo`segments[].start` | Tiponumber |
| Campo`segments[].end` | Tiponumber |

Errori e passaggi successivi

| Risposta | Condizione | Passaggio successivo |
| --- | --- | --- |
| Risposta400 · `invalid_request_error` | CondizioneCampi obbligatori, rappresentazione del materiale o valore del parametro non validi | Passaggio successivoCorreggi i campi indicati prima di una nuova richiesta di creazione. |
| Risposta`server_error` | CondizioneLa risposta restituita indica che l'operazione o il risultato richiede una verifica | Passaggio successivoConserva l'ID originale di operazione/task restituito, gli header della richiesta e la risposta; continua a leggere l'operazione originale tramite le modalità supportate. Non reinviare la richiesta di creazione. |

### Alias

#### Alias del modello

**Ailoot Ultra** [`openai/gpt-4o-transcribe-diarize`](https://ailoot.ai/models/it/#m=openai%2Fgpt-4o-transcribe-diarize&route=Ultra&caller=openai%2Fgpt-4o-transcribe-diarize&fmt=transcriptions)

#### Alias dei percorsi dei metodi

`/audio/transcriptions`

#### ID di chiamata correlati

[`openai/gpt-4o-transcribe-diarize`](https://ailoot.ai/models/it/#m=openai%2Fgpt-4o-transcribe-diarize&route=Ultra&caller=openai%2Fgpt-4o-transcribe-diarize&fmt=transcriptions)

FAQ · gpt-4o-transcribe-diarize

Quali input e risultati sono disponibili?

`POST /v1/audio/transcriptions` · `openai/gpt-4o-transcribe-diarize`: `audio` → `transcription`

Quali campi usa la richiesta?

`POST /v1/audio/transcriptions` · `openai/gpt-4o-transcribe-diarize`: `model`, `file`, `response_format`

Collega Ailoot a Claude Code, OpenCode, Hermes o alla tua applicazione.

## L’azienda e il suo portafoglio di progetti

L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.

## Acquista token con uno sconto.

Sconto con abbonamento per lavoro regolare. Codici fino al 50% sull’acquisto di token.

Abbonamento

Scegli un piano scontato per richieste regolari.

Codice fino al 50%

Inserisci il codice all’acquisto. Il prezzo si aggiorna secondo la promozione.

Spese nella cronologia

Modello, token e importo sono salvati per ogni richiesta.

[Scegli abbonamento](https://ailoot.ai/docs/it/billing/subscriptions/) · [Consulta prezzi dei modelli](https://ailoot.ai/models/it/)

## Collega l’API al prodotto che vendi.

SaaS, app e bot secondo offerta e accordo di licenza Ailoot. Per rivendere, richiedi una licenza reseller.

Applicazione commerciale

Integra generazione di testo, immagini, video e suono nelle funzioni a pagamento.

Licenza reseller

Invia descrizione del progetto e schema di accesso. Richiedi condizioni scritte per uso e rivendita.

Documenti sul sito

Offerta, accordo di licenza e politica sui dati sono disponibili prima della connessione.

[Richiedi licenza reseller](mailto:support@ailoot.ai) · [Offerta e accordo di licenza](https://ailoot.ai/legal/offer?lang=it)

## Ailoot · L’azienda e il suo portafoglio di progetti





Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.





L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.





Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.
