# General Translation Knowledge Base: Come si traducono i sottotitoli SRT senza alterare la temporizzazione? URL: https://generaltranslation.com/it/kb/translate-srt-subtitles.mdx Docs index: https://generaltranslation.com/llms.txt Description: In un file SRT traduci solo il testo dei cue; lascia numeri dei cue, timecode, righe vuote di separazione e tag di formattazione come nel file sorgente. Poi verifica la lunghezza delle righe e la velocità di lettura rispetto ai requisiti della piattaforma di destinazione: la guida di Netflix per l'inglese, ad esempio, consente 42 caratteri per riga e 20 caratteri al secondo per i programmi destinati agli adulti. Category: Traduzione Last updated: 2026-10-20 Authors: Kevin Wu, Jackie Chen Published: 2026-10-20 SRT (SubRip) non ha una specifica formale. La Library of Congress lo definisce ["non ben standardizzato"](https://www.loc.gov/preservation/digital/formats/fdd/fdd000569.shtml): player e piattaforme accettano quindi cose diverse, e un file tradotto è tanto più sicuro quanto più resta semplice come il file sorgente. ## Cosa contiene un file SRT Un file SRT è un elenco di cue separati da righe vuote. Ogni cue è composto da un numero progressivo, una riga di temporizzazione nel formato `HH:MM:SS,mmm --> HH:MM:SS,mmm` (con una virgola prima dei millisecondi) e una o più righe di testo: ```text title="subtitles/en/intro.srt" 1 00:00:01,000 --> 00:00:03,500 Welcome back to the channel. 2 00:00:03,600 --> 00:00:06,200 Today we're looking at how subtitles are timed. 3 00:00:06,400 --> 00:00:08,000 Let's get started. ``` Questa guida adotta un flusso di lavoro a tempi fissi: si traduce il testo mantenendo invariata la struttura dei cue esistente. Se la lingua di destinazione richiede tempi o confini dei cue diversi, apporta queste modifiche in un editor di sottotitoli, verificandole sul video, e valida separatamente il risultato modificato. * **I numeri dei cue**, in ordine, uno per cue. * **Le righe di temporizzazione**, carattere per carattere. Un punto al posto della virgola o un millisecondo fuori posto possono indurre un player a scartare il cue o a mostrarlo nel momento sbagliato. * **La riga vuota tra i cue.** Se mancano i separatori, un player può unire, interpretare male o saltare i cue coinvolti. I cue successivi hanno timestamp assoluti: i loro tempi non si spostano automaticamente. * **Gli a capo all'interno di un cue**, che mantengono ogni riga abbastanza corta da poter essere letta. Una traduzione può spostare il punto in cui una riga va a capo, ma non dovrebbe aggiungere una terza riga. * **I tag** come ``, `` e ``, e i tag di posizione come `{\an8}`, che i player interpretano come formattazione. Se vengano renderizzati o meno dipende dal player: YouTube, ad esempio, accetta solo file SRT di base, non riconosce alcun markup e richiede UTF-8 semplice ([file di sottotitoli supportati](https://support.google.com/youtube/answer/2734698)). * **La codifica del testo.** SRT non prevede uno standard di codifica, quindi salva le traduzioni in UTF-8, a meno che il tuo player non richieda altro. ## Lunghezza delle righe e velocità di lettura La temporizzazione resta fissa mentre il testo tradotto cambia lunghezza, quindi un sottotitolo che in inglese si leggeva comodamente può scorrere troppo in fretta in un'altra lingua. Netflix pubblica limiti specifici per ciascuna lingua. La sua [English (USA) Timed Text Style Guide](https://partnerhelp.netflixstudios.com/hc/en-us/articles/217350977-English-USA-Timed-Text-Style-Guide) prevede 42 caratteri per riga, un massimo di due righe e una velocità di lettura fino a 20 caratteri al secondo per i programmi per adulti (17 per quelli per bambini). La [guida per il tedesco](https://partnerhelp.netflixstudios.com/hc/en-us/articles/217351587-German-Timed-Text-Style-Guide) mantiene i 42 caratteri per riga, ma abbassa la velocità di lettura a 17 caratteri al secondo per gli adulti e a 13 per i bambini. Una traduzione può richiedere più caratteri del testo sorgente, mentre il tempo disponibile resta invariato. Calcola i caratteri al secondo in base a ciascun cue tradotto e alla sua durata; la larghezza del testo renderizzato è una misura diversa. Se un cue supera i limiti previsti dalle specifiche di consegna, riformulalo senza alterarne il significato e controllalo nel video. ## Cue per cue o con l'intero file come contesto Spesso una battuta di dialogo si estende su due o tre cue. Tradurre ogni cue singolarmente mantiene intatta la struttura, ma significa tradurre frammenti: il tedesco, ad esempio, colloca il verbo alla fine della proposizione subordinata, e il verbo potrebbe finire nel cue successivo. Tradurre usando come contesto i cue adiacenti dà un risultato più scorrevole, purché il testo venga poi reinserito negli stessi cue con le stesse temporizzazioni. ## Modi per tradurre un file SRT | Approccio | Gestione della struttura SRT | Traduzione automatica | Controlli sulla velocità di lettura | Ideale quando | | -------------------------------------- | --------------------------------------------------------------------------------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- | | Subtitle Edit (gratuito, open source) | Legge e scrive file SRT | Google Translate, DeepL, API di LLM e modelli locali | Controlli in stile Netflix su caratteri al secondo, lunghezza e numero di righe | Una sola persona traduce e rifinisce un file a mano | | Traduzione di documenti DeepL | Accetta il caricamento di file `.srt` | DeepL | Nessuno | Ti serve una prima bozza rapida di un singolo file | | Google Translate | Nessun caricamento di SRT, né nell'app consumer né nella traduzione di documenti di Cloud | Solo API di testo; il file va ricostruito | Nessuno | Prevedi di scrivere uno script e di gestire i file in autonomia | | CLI di General Translation | L'elaborazione SRT dedicata preserva i tempi dei cue e il markup protetto | Servizio di GT con Glossario e prompt personalizzati condivisi | Esegui i controlli riportati di seguito e verifica il risultato sul video | Sottotitoli versionati insieme ai rilasci periodici del prodotto o della documentazione | | Passare il file a un LLM con un prompt | Legge il file come testo semplice; nulla garantisce che la struttura resti intatta | Qualsiasi modello a tua scelta | Solo se lo richiedi, e senza verifica | Un file isolato da controllare riga per riga | Qualche dettaglio sulla tabella. YouTube Studio non compare perché si limita a pubblicare i sottotitoli, non a tradurli: una volta ottenuto il file tradotto, apri **Subtitles**, seleziona il video, fai clic su **Add language**, scegli la lingua e carica il file ([aggiungere sottotitoli](https://support.google.com/youtube/answer/2734796)). Questo caricamento presuppone quindi che la traduzione esista già. [Subtitle Edit](https://github.com/SubtitleEdit/subtitleedit) (con licenza MIT, disponibile per Windows, macOS e Linux) offre una finestra di dialogo **Translate > Auto-translate** con motori come Google Translate, DeepL, ChatGPT, Claude, Gemini e modelli locali tramite Ollama, oltre allo strumento di controllo **Tools > Check and fix Netflix errors**. L'[API per documenti](https://developers.deepl.com/api-reference/document) di DeepL include `srt` tra i formati supportati. La [traduzione di documenti](https://docs.cloud.google.com/translate/docs/advanced/translate-documents) di Google accetta file Office e PDF, mentre il [sito consumer](https://support.google.com/translate/answer/2534559?co=GENIE.Platform%3DDesktop) accetta solo `.docx`, `.pdf`, `.pptx` e `.xlsx`. Usa Subtitle Edit quando una sola persona traduce e rifinisce un file a mano, perché affianca alla traduzione automatica i controlli su tempi e velocità di lettura. Usa la traduzione di documenti di DeepL per ottenere rapidamente una prima bozza di un singolo file. Scegli General Translation quando gli stessi file di sottotitoli cambiano a ogni rilascio e devono condividere la terminologia con la tua app e la tua documentazione; per la revisione finale sul video, affidati a un editor di sottotitoli. ## Verifica il file tradotto Questo script Node.js verifica che un file tradotto abbia lo stesso numero di cue, la stessa numerazione dei cue e gli stessi timecode del file sorgente, e che nessun cue sia vuoto. Passa un terzo argomento per segnalare i cue che superano una determinata velocità di lettura, ad esempio 17 caratteri al secondo per il tedesco: ```js title="check-srt.mjs" // Uso: node check-srt.mjs [numero massimo di caratteri al secondo] import { readFileSync } from 'node:fs'; const TIMING = /^(\d{2}:[0-5]\d:[0-5]\d,\d{3}) --> (\d{2}:[0-5]\d:[0-5]\d,\d{3})$/; const cues = (file) => readFileSync(file, 'utf8') .replace(/^/, '') .split(/\r?\n\s*\r?\n/) .map((block) => block.trim().split(/\r?\n/)) .filter((lines) => lines[0]) .map(([number, timing = '', ...text]) => ({ number, timing, text })); const [srcFile, outFile, maxCps] = process.argv.slice(2); if (!srcFile || !outFile || (maxCps !== undefined && !(Number(maxCps) > 0 && Number.isFinite(Number(maxCps))))) { throw new Error('Provide source and translated files, and an optional positive reading-speed limit.'); } const [source, target] = [srcFile, outFile].map(cues); const seconds = (tc) => tc.split(/[:,]/).reduce((acc, n, i) => acc + n * [3600, 60, 1, 0.001][i], 0); const problems = []; if (!source.length) problems.push('source has no cues'); if (source.length !== target.length) problems.push(`cue count: ${source.length} in source, ${target.length} translated`); source.forEach((cue, i) => { const t = target[i]; if (!t) return; if (cue.number !== t.number) problems.push(`cue ${i + 1}: number "${cue.number}" became "${t.number}"`); if (!TIMING.test(t.timing)) problems.push(`cue ${cue.number}: invalid timing line "${t.timing}"`); else if (cue.timing !== t.timing) problems.push(`cue ${cue.number}: timing changed to "${t.timing}"`); if (!t.text.join('').trim()) problems.push(`cue ${cue.number}: empty text`); const [, start, end] = TIMING.exec(t.timing) ?? []; const duration = start ? seconds(end) - seconds(start) : 0; if (start && duration <= 0) problems.push(`cue ${cue.number}: end must be after start`); if (maxCps && duration > 0) { // Conta spazi e punteggiatura, ma non il markup come o {\an8} const chars = t.text.join(' ').replace(/<[^>]+>|\{\\an\d\}/g, '').length; const cps = chars / duration; if (cps > maxCps) problems.push(`cue ${cue.number}: ${cps.toFixed(1)} characters per second`); } }); console.log(problems.length ? problems.join('\n') : `OK: ${source.length} cues, numbers and timecodes match`); process.exitCode = problems.length ? 1 : 0; ``` Ecco due traduzioni del file di esempio. Quella spagnola conserva tutti i cue. Quella tedesca riduce tre cue a due e inserisce un punto in un timecode: ```text title="subtitles/es/intro.srt" 1 00:00:01,000 --> 00:00:03,500 Bienvenidos de nuevo al canal. 2 00:00:03,600 --> 00:00:06,200 Hoy veremos cómo se sincronizan los subtítulos. 3 00:00:06,400 --> 00:00:08,000 ¡Empecemos! ``` ```text title="subtitles/de/intro.srt" 1 00:00:01,000 --> 00:00:03,500 Willkommen zurück auf dem Kanal. Heute sehen wir uns an, 2 00:00:03,600 --> 00:00:06.200 wie Untertitel getimt werden. Los geht's! ``` Eseguendolo con Node.js 24, lo script supera il controllo sul file spagnolo ma non su quello tedesco. Ora il cue 1 contiene 56 caratteri in 2,5 secondi: ```bash $ node check-srt.mjs subtitles/en/intro.srt subtitles/es/intro.srt 20 OK: 3 cues, numbers and timecodes match $ node check-srt.mjs subtitles/en/intro.srt subtitles/de/intro.srt 17 cue count: 3 in source, 2 translated cue 1: 22.4 characters per second cue 2: invalid timing line "00:00:03,600 --> 00:00:06.200" ``` Lo script termina con codice 1 al primo problema, quindi può essere eseguito in CI dopo la traduzione. Accetta le righe di temporizzazione semplici mostrate qui, senza le coordinate di posizione facoltative. Verifica la corrispondenza dei cue, la validità delle temporizzazioni, che il testo non sia vuoto e, facoltativamente, un limite di velocità. Non verifica la conservazione dei tag, la lunghezza o il numero delle righe né il significato: usa il validatore di sottotitoli della piattaforma di destinazione e rivedi il risultato insieme a un revisore che parla la lingua. Il conteggio dei caratteri in JavaScript è un controllo preliminare e non sostituisce le regole di conteggio specifiche di ciascuna piattaforma. ## Come tradurre i file SRT con General Translation Se i file di sottotitoli si trovano in un repository e vanno tradotti in più lingue a ogni modifica, puoi usare la CLI di General Translation, `gt`, che supporta i file `.srt` a partire dalla versione 2.22.2. Dopo averla installata ed esserti autenticato (consulta l'[Avvio rapido della CLI](/docs/cli/quickstart)), aggiungi una voce `srt` sotto `files` in `gt.config.json`, inserendo un segnaposto `[locale]` nel percorso: ```json title="gt.config.json" { "defaultLocale": "en", "locales": ["es", "de"], "files": { "srt": { "include": ["subtitles/[locale]/**/*.srt"] } } } ``` Poi esegui [`npx gt translate`](/docs/cli/reference/commands/translate). La CLI legge i sottotitoli sorgente da `subtitles/en/` e scrive le traduzioni in `subtitles/es/` e `subtitles/de/`. Per tradurre in inglese, imposta `defaultLocale` sulla lingua di origine e aggiungi `"en"` a `locales`. Viene tradotto solo il testo dei cue. I numeri dei cue, le righe di temporizzazione (compresi i dati di posizione che seguono i timestamp), le righe vuote di separazione, il markup come `` e `` e i tag di posizione iniziali da `{\an1}` a `{\an9}` restano invariati, così come qualsiasi blocco privo di una riga di temporizzazione valida. Le righe tradotte mantengono i caratteri di fine riga del cue e i file scaricati usano la codifica del file sorgente. I cue non modificati possono riutilizzare le traduzioni precedenti e il Glossario e i prompt personalizzati del progetto valgono anche per i sottotitoli. (Consulta il [riferimento al formato SRT](/docs/cli/reference/formats/srt-files) e [Definire il contesto per le traduzioni](/docs/platform/dashboard/guides/defining-context-for-translations)). Le righe di temporizzazione restano identiche a quelle del file sorgente, quindi esegui lo script di controllo indicato sopra su ogni file tradotto, soprattutto per le lingue che tendono a produrre testi più lunghi della lingua di origine. ## Punti chiave * In una traduzione a tempi fissi, modifica il testo dei cue mantenendo invariati i numeri dei cue, le righe di temporizzazione, i separatori e i tag di formattazione. Le modifiche intenzionali ai tempi o ai limiti dei cue vanno verificate a parte sul video. * Netflix consente al massimo due righe da 42 caratteri ciascuna, con una velocità di lettura fino a 20 caratteri al secondo in inglese e 17 in tedesco per i programmi destinati a un pubblico adulto. * La traduzione di documenti di DeepL e Subtitle Edit accettano file SRT, mentre il caricamento di documenti di Google Translate no. * La CLI `gt` (versione 2.22.2 o successiva) traduce i file SRT quando aggiungi `files.srt.include` con un percorso `[locale]` ed esegui [`npx gt translate`](/docs/cli/reference/commands/translate): traduce solo il testo dei cue e lascia i tempi identici a quelli della sorgente. ## Related questions - [Come tradurre Markdown e MDX senza compromettere la sintassi?](https://generaltranslation.com/it/kb/translate-markdown-files.mdx): Traduci il testo descrittivo, il testo alt delle immagini, i titoli e le descrizioni nel frontmatter e le props dei componenti che mostrano testo. Lascia invariati blocchi di codice, codice inline, import, nomi dei componenti JSX, chiavi del frontmatter e URL dei link, a meno che una mappatura dei locale non li riscriva. Racchiudi tra virgolette i valori YAML tradotti, quindi esegui la build del sito. - [Come si traducono i file JSON di i18n?](https://generaltranslation.com/it/kb/translate-json-files.mdx): Traduci solo i valori stringa di un file JSON di impostazione regionale. Lascia invariati le chiavi non plurali, i segnaposto come {{name}} e i tag, ma tieni presente che le chiavi plurali cambiano da una lingua all'altra: il polacco, ad esempio, richiede inbox_few e inbox_many. Usa uno strumento o un'API in grado di gestire il formato, quindi esegui il parsing dell'output e validalo prima della revisione. - [La traduzione con l'IA è abbastanza accurata per un'app in produzione?](https://generaltranslation.com/it/kb/is-ai-translation-accurate.mdx): Spesso sì, per le lingue più diffuse, ma solo dopo aver superato una valutazione sulle tue lingue, sulle tue stringhe di UI e sui contenuti più a rischio. Al WMT25, Gemini 2.5 Pro ha eguagliato o superato le traduzioni umane di riferimento in 10 coppie linguistiche su 16, ma un benchmark sui documenti non dice se brevi stringhe di interfaccia siano pronte per il rilascio. - [Alternative a Google Translate: General Translation vs. Google Translate](https://generaltranslation.com/it/kb/general-translation-vs-google-translate.mdx): Google Translate è un modo rapido per tradurre testi occasionali, ma pubblicare un prodotto in un'altra lingua richiede anche che ogni stringa sia tradotta nel suo contesto, con termini coerenti, variabili e plurali corretti, una revisione e un processo di rilascio. General Translation comprende il contesto di ogni stringa nel tuo codice e automatizza l'intero flusso di lavoro di localizzazione, dal codice alla revisione fino a ogni rilascio. ## Previous and next questions - Previous question: [Come si traducono i file JSON di i18n?](https://generaltranslation.com/it/kb/translate-json-files.mdx) - Next question: [Come si trovano le stringhe hardcoded non tradotte?](https://generaltranslation.com/it/kb/find-hardcoded-strings.mdx) ## Sitemap See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.