# Risolvere l’errore 403 Forbidden di yt-dlp

Aggiorna la versione nightly, riduci le richieste simultanee, verifica Deno e poi prova i cookie e un IP di uscita funzionante.

Riferimento canonico: https://flashdata.dev/it/docs/guides/yt-dlp-403-forbidden
Recensito: 2026-11-13 da FlashData

- [Inizia a fallire dopo il lavoro](https://flashdata.dev/it/docs/guides/yt-dlp-403-forbidden/reference.md#versions) — Aggiornare il lavoratore reale al notturno
- [Il fallimento, con la concorrenza in aumento](https://flashdata.dev/it/docs/guides/yt-dlp-403-forbidden/reference.md#rate) — Riduzione dei lavoratori, dei fragmenti e delle connessioni
- [Questo proxy IP continua a fallire](https://flashdata.dev/it/docs/guides/yt-dlp-403-forbidden/reference.md#environment) — Testare e mantenere una riga di uscita sostitutiva
- [Avvertimento o avvertimento di token](https://flashdata.dev/it/docs/guides/yt-dlp-403-forbidden/reference.md#challenges) — Verifica prima il deno, poi il contesto token

<a id="clean-test"></a>

## Prova questo prima


1. **Aggiornare di notte.** Aggiornare l'ambiente Python utilizzato dal lavoratore fallito.
2. **Riduce il carico.** Parallel lavoro in questo IP; testare un video e un fragmento contemporaneamente.
3. **Check Deno.** Confirmare che il log verboso rileva il tempo di funzionamento.
4. **Tro cookie validi.** Per un piccolo lavoro, utilizzare una sessione del browser che può giocare la fonte.
5. **Rimposta un IP rifiutato.** Inizia una fresca estrazione attraverso una salutare host o una uscita proxy.

**Aggiornare, quindi controllare il tempo di funzionamento richiesto**

```bash
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
python -m yt_dlp --version
deno --version
```

**Una fonte, una trasmissione a basso carico**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" --downloader native \
  --concurrent-fragments 1 --limit-rate 2M --sleep-requests 2 \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Utilizzare la URL fallita, quindi un breve video pubblico come controllo.Questa sonda audio-uni evita FFmpeg e salva un nuovo nome di file timestampato per ogni tentativo.

**Run sul fallito operaio.** Verifica la verboza `Proxy map` per la sua rotta reale. `--ignore-config` rimuove le opzioni salvate ma mantiene installati i plug-ins e i proxy ambientali.

**Successo significa un file salvato.** Una volta che l'audio funziona, testare il video con `-f bv`, quindi ripristinare le impostazioni di uscita complete. `--simulate` e `-F` non testare un trasferimento multimediale. Il capo `2M` è un punto di partenza per la diagnosi.

- [Impostazione Linux: notturno, Deno e curl-cffi](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [errore di registrazione / bot-check](https://flashdata.dev/it/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [HTTP 429 Limiti di tasso](https://flashdata.dev/it/docs/guides/yt-dlp-429-too-many-requests/reference.md)

<a id="versions"></a>

## 1 Aggiornamento a notte


**Un comando che funziona in precedenza improvvisamente fallisce:** aggiornamento prima. i cambiamenti di giocatore di YouTube possono rompere gli estrattori più vecchi; l'ultimo notturno può già contenere la riparazione.

**Aggiornare l'ambiente Python del lavoratore**

```bash
python -m pip install -U --pre "yt-dlp[default,curl-cffi]"
python -m yt_dlp --version
python -c "import sys, yt_dlp; print(sys.executable); print(yt_dlp.__file__)"
```

**Se invece si utilizza l'esecutabile ufficiale**

```bash
yt-dlp --update-to nightly
yt-dlp --version
```

yt-dlp -U solo aggiornamenti all'interno del canale corrente. Utilizzare --update-to di notte per scorrere da stabile.

Ristrutturare e riavviare un contenitore se la sua immagine contiene un pacchetto vecchio; aggiornare Python sul host non aggiornano quel contenitore.

Rimuovere vecchi player_client, player_js_version e formati=missing_pot superridi per la linea di base. Un operaio di un vecchio incidente può ora selezionare un cliente inadeguato o esponere un flusso il cui token è ancora mancante. Il problema #14680 è un esempio di un cambiamento del giocatore in un upstream fisso; copiare il suo sovrido temporaneo indefinitamente non è il fisso.

- [Rilasciare canali e aggiornamenti](https://github.com/yt-dlp/yt-dlp#update)
- [Incidente di cambio di giocatore: #14680](https://github.com/yt-dlp/yt-dlp/issues/14680)

<a id="rate"></a>

## 2 Riduzione delle richieste concorrenti


**Download funziona, poi fallisce come il volume aumenta:** riduce la carica totale sull'IP di uscita.In esperienza di FlashData, i trasferimenti paralleli rapidi possono provocare il rifiuto.

| Fonte di carico | Prima diagnosi di impostazione |
| --- | --- |
| Video concorrenti di lavoro | Un video attivo per questo IP di uscita; fermare temporaneamente il resto della coda. |
| Richieste di fragmenti nativi | --concurrent-fragments 1. |
| aria2 o un altro download esterno | Torna a --downloader native. Se in seguito riattivi aria2, inizia con -x 1 -s 1 -j 1. |
| Media di banda | Prova --limit-rate 2M come test conservativo, poi aumenta gradualmente. |
| Extrazione e nuovi download | Utilizzare --sleep-requests 2 e --sleep-interval 5 --max-sleep-interval 10. |
| Ritorno Nested | Mantenere limitati i numeri di retrazione a livello di lavoro e di download; non moltiplicarli tra i lavoratori. |

**Rimuovere il video richiesto a bassa carica**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  --downloader native --concurrent-fragments 1 --limit-rate 2M --sleep-requests 2 \
  --sleep-interval 5 --max-sleep-interval 10 --retries 1 --fragment-retries 1 -f bv \
  -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Se il trasferimento a basso carico funziona, mantenere quella linea di base e aumentare una dimensione contemporaneamente mentre guardano i fallimenti. Se non è ancora in grado di farlo subito dopo i controlli nightly/runtime, non continuare a ridurre la larghezza di banda indefinitamente: testare un'IP di uscita diversa. Un percorso già segnato da YouTube può rimanere respinto dopo che il traffico che lo ha portato è stato interrotto.

- [aria2 Controlli di connessione](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#aria2)
- [Richiesta di pacchetto per metadati e capzioni](https://flashdata.dev/it/docs/guides/yt-dlp-429-too-many-requests/reference.md#pacing)

<a id="challenges"></a>

## 3 Il controllo del deno


**Check entrambe le dipendenze sul lavoratore:** Deno corre le sfide; `yt-dlp-ejs` fornisce i script solver. Il `[default]` aggiuntivo installa gli scritti. Installare il Deno separatamente.

**Verifica le dipendenze dei lavoratori**

```bash
deno --version
python -m pip show yt-dlp yt-dlp-ejs
python -m yt_dlp --list-impersonate-targets
```

**Controlla la rilevazione del tempo di funzionamento e la soluzione del problema**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  --simulate "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Leggi la linea di corrispondenza JS per Deno, e qualsiasi messaggio [jsc:deno] che risolve. Un tempo di esecuzione mancante o un avvertimento signature/n-challenge deve essere risolto prima di un altro grande esecuzione di download. Deno 2.3+ è il minimo attuale nella documentazione EJS in upstream; utilizzare una versione supportata aggiornata.

**Servizio Linux con Deno fuori PATH**

```bash
python -m yt_dlp --ignore-config --js-runtimes "deno:/opt/deno/bin/deno" --impersonate="" \
  --verbose --simulate "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Sostituisci /opt/deno/bin/deno con l'esecutabile reale. su macOS o Windows, utilizzare invece quella strada assoluta del lavoratore Deno.

Il curl-cffi extra consente --impersonate="". Fornisce impronte digitali come il browser; non sostituisce Deno. Se il target del browser non è disponibile, installare l'eccesso nello stesso ambiente Python. Se l'impersonazione presenta un fallimento su una rotta di lavoro, confrontare la richiesta identica senza la bandiera.

Dopo il controllo della dipendenza, rerun la trasmissione dei media reali. Se la notte corrente ancora segnalare fallimento di firma-solvente per lo stesso giocatore, salvare l'ID del giocatore e il messaggio di solvente per il problema di upstream corrispondente. Se la soluzione è riuscita e i media ricevono 403, proseguire a session/IP controlli.

- [Testimonianze e EJS supportate](https://github.com/yt-dlp/yt-dlp/wiki/EJS)
- [Impostazione completa Linux](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#install)

<a id="cookies"></a>

## 4 Prova cookie validi per un piccolo lavoro


**Testare una sessione di lavoro conosciuta.** Confirmare che il browser può giocare la fonte esatta, quindi provare i suoi cookie con lo stesso comando e la stessa rotta.

**Utilizzare la sessione di Firefox**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" --cookies-from-browser firefox \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

**Utilizzare una sessione esportata su un lavoratore senza capo**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" --cookies private/youtube-cookies.txt \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Utilizzare i cookie di formato Netscape. mantenere il file privato e scrittibile per questo lavoro; per un segreto di lettura, fare una copia per lavoro.

Se i cookie vengono caricati ma YouTube dice che non sono più validi, sostituite la sessione piuttosto che passando ripetutamente lo stesso file. Per alcuni video, mantenere un login del browser può essere pratico. Per una grande collezione di video pubblico, trovare e rinfrescare molte sessioni del browser non è una strategia di scalazione dipendente.

Per il lavoro di massa, gestire un pool di usabili IP di uscita proxy e girare ai confini di lavoro, con un basso budget per richiesta IP. Mantenere i cookie di account per le fonti che richiedono effettivamente l'accesso al conto. Un cambiamento IP non consente l'accesso a un video privato o non disponibile.

- [Procedura di esportazione e rinnovo dei cookie](https://flashdata.dev/it/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md#renew-session)
- [Copie di cookie scritte nei contenitori](https://flashdata.dev/it/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md#server)

<a id="environment"></a>

## 5. sostituire un IP di uscita rifiutato


**Lo stesso video pubblico, le stesse impostazioni, il risultato differente per IP:** sostituisce la uscita fallita. FlashData vede molti persistenti 403s causati da IP proxy poveri o flagellati. Ripristinare yt-dlp non ripara quella rotta.

1. Mantenere la fonte, revisione notturna, Deno, cookie se necessario e il formato selettore lo stesso.
2. Testare un'IP di uscita sostitutiva con una fresca estrazione e un vero trasferimento di media.
3. Confirmare che il proxy ha effettivamente cambiato il suo IP di uscita. Un nuovo nome di host o credentiale di gateway può ancora portare alla stessa uscita.
4. Mantenere una sessione proxy stretta durante l'estrazione, la generazione di token e il trasferimento dei media.
5. Rimuovere o raffreddare la uscita fallita nella piscina.Rota verso un'altra uscita sana per un nuovo lavoro o una retrazione controllata.

**Prova di una sessione proxy sostitutiva**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" --proxy "http://USER:PASSWORD@HOST:PORT" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Il log verbosa può esponere credenziali proxy; redigere prima di condividere.

**Confronta l'accesso diretto all'host quando disponibile**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" --proxy "" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Questo disabilita environment/configured proxy per il test. Scappare quando l'host non può raggiungere YouTube direttamente.

**Confronta la rotta IPv4 dell'host**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" \
  --force-ipv4 "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Un percorso IPv4 funzionale può differire dal percorso IPv6 fallito. con un proxy, -4 non seleziona necessariamente la famiglia IP di outbound del proxy.

| Risultato | Prossima azione |
| --- | --- |
| La stessa fonte riesce su un nuovo IP di uscita | Mantieni quella rotta e la sua basilica a basso carico. Quarantina la uscita fallita piuttosto che ritirarla per ogni video. |
| Il cambiamento delle credenziali proxy non ha effetto | Verifica la vera politica di ingresso IP e sessione; il proxy può ancora utilizzare la stessa uscita. |
| Il giocatore funziona, i media falliscono solo attraverso il proxy | Verifica l'accesso a googlevideo.com e che i media utilizzano lo stesso exit/session. |
| Una fonte fallisce su ogni percorso testato; il controllo funziona | Ricerca quella fonte, formato e stato di vita. Non etichettare l'intero pool proxy rotto da un video. |

- [Diagnosi di flusso network/IP e richiesta di volume](https://github.com/yt-dlp/yt-dlp/issues/17103)

<a id="media-urls"></a>

## Avanzato: mantenere l'estrazione e il trasferimento su un unico IP


Un bug di applicazione comune è quello di estrarre `info['url']` su una macchina, memorizzarla in una coda e scaricarla in un altro luogo. Le URL dei media firmate scadono e possono dipendere dall'IP originale e dai titoli di richiesta. Un proxy rotativo può creare lo stesso divario anche all'interno di una sola applicazione.

Scopri l'ID video di YouTube e le impostazioni di uscita desiderate. Lascia che il lavoratore esegue una nuova estrazione e scarica insieme. Se il lavoratore utilizza un proxy, mantenere lo stesso progresso attraverso l'estrazione del giocatore, la generazione di token e le richieste dei media. Chiedi al fornitore di proxy per una sessione di stretto, invece di rotare ogni richiesta HTTP.

**Mantenere l'estrazione e il trasferimento nello stesso lavoro di Python**

```python
from yt_dlp import YoutubeDL
from yt_dlp.networking.impersonate import ImpersonateTarget

options = {
    "js_runtimes": {"deno": {}},
    "impersonate": ImpersonateTarget(),
    "format": "ba",
    "outtmpl": "diagnostics/%(id)s-%(epoch)s.%(ext)s",
    "noplaylist": True,
    "verbose": True,
    # If required, configure one sticky proxy for the entire job:
    # "proxy": "http://USER:PASSWORD@HOST:PORT",
}
with YoutubeDL(options) as downloader:
    downloader.download(["https://www.youtube.com/watch?v=jNQXAC9IVRw"])
```

Questo è un download locale diretto; non ha bisogno di una chiave API. Aggiungi le opzioni verifiche cookie/provider solo se i test precedenti li richiedono.

Se questo succede mentre `requests.get(saved_media_url)` o un processo separato FFmpeg fallisce, verifica che il disastro: URL età, titoli forniti da estrattore, cookie e effettivo progresso. Mantenere gli URL dei media fuori dai record di lavoro duraturo. Quando si ritirano i risultati di estrazione scaduto, chiedere URL fresche dall'ID video originale.

- [Spiegata spiegazione degli errori di URL extractati](https://github.com/yt-dlp/yt-dlp/wiki/FAQ#i-extracted-a-video-url-but-it-does-not-play-on-another-machine--in-my-web-browser)

<a id="triage"></a>

## Avanzato: identificare la richiesta fallita


**La sequenza della richiesta**

```text
Watch page / player response
  → available streams and their signed URLs
  → googlevideo.com media bytes or fragments
  → local FFmpeg processing
```

`-F` elenca i formati estratti; `--simulate` si ferma prima di salvare i media. Non dimostra nemmeno che il flusso selezionato restituirà i byti. Se il log raggiunge `Downloading 1 format(s)` e poi fallisce con un dati di media 403, cambiando il nome del file di uscita o installando FFmpeg non riparerà la richiesta HTTP.

I profili dei clienti di YouTube come `mweb` e `web_safari` cambiano le richieste di risposta del giocatore yt-dlp. Alcune risposte richiedono una trasformazione di firma o n-parametro; alcune richieste di media richiedono anche un GVS proof-of-origin token. Un token PO per la richiesta del giocatore non è scambiabile con uno per la consegna dei media o per i sottotitoli.

| Localizzazione Log | Interpretazione |
| --- | --- |
| `Unable to download API page` / `Unable to download webpage` | Identificare che host prima di trattarlo come un fallimento del server media. |
| `unable to download video data: HTTP Error 403: Forbidden` | La richiesta di media selezionata è stata respinta. Seguire le fili solver/token/route qui sotto. |
| Il segreto del messaggio di retry | Mantenere l'errore del fragmento e il protocollo; confrontare un altro formato disponibile invece di ritirare lo stesso fragmento indefinitamente. |
| FFmpeg dice HTTP 403 mentre legge un input | FFmpeg è un'eruzione di media remote, ad esempio per un clip. Verificare l'URL e la rete trasferita a FFmpeg; questo non è un errore di codec locale. |
| Il caricamento sullo storage restituisce `AccessDenied` | Il file è arrivato alla fase di upload.Fix bucket access e retry che upload, non il download YouTube. |

<a id="po-token"></a>

## Avanzato: installare un fornitore di PO-token


Utilizzare questa ramo quando i formati necessari sono scappati per un token GVS mancante, o il tuo token configurato è rifiutato. I tokens sono collegati a un contesto client/request e possono essere collegati all'ID video. Un token copiato per un video non è una credenziale riutilizzabile per un intero cavo. Utilizzare un fornitore per generare il token per la richiesta corrente.

> **Un avvertimento può descrivere un fallback scappato**
> Se un altro cliente ha già fornito il file richiesto, un avvertimento del cliente scappato non è solo una scarica fallita. indagare quando il flusso richiesto è mancante o la richiesta media selezionata fallisce.

Il seguente setup utilizza bgutil 2.0.2. Ha due parti: un plugin Python caricato da yt-dlp e un servizio JavaScript che genera token. Mantenere le versioni alineate durante l'aggiornamento. I seguenti esempi utilizzano un servizio raggiungibile sullo stesso host al porto 4416.

**Installare il connettore nell'ambiente Python di yt-dlp**

```bash
python -m pip install "bgutil-ytdlp-pot-provider==2.0.2"
```

**Docker**

Per yt-dlp eseguire sul host Docker. Pubblicare solo il port loopback.


**Inizia il fornitore**

```bash
docker run --name bgutil-provider -d --init -p 127.0.0.1:4416:4416 brainicism/bgutil-ytdlp-pot-provider:2.0.2
```


**Node senza Docker**

Require Git, Node 22+ e npm. Eseguire l'ultimo comando in un terminale separato e lasciarlo funzionare. Se la cartella esiste già, utilizzare il check-out esistente del rilascio corrispondente.


**Costruisci e inizia il provider nativo**

```bash
git clone --depth 1 --branch 2.0.2 https://github.com/Brainicism/bgutil-ytdlp-pot-provider.git
cd bgutil-ytdlp-pot-provider/server
npm ci
npx tsc
node build/main.js --host 127.0.0.1 --port 4416
```


**Verifica il servizio dall'ambiente del download**

```bash
python -c "from urllib.request import urlopen; print(urlopen('http://127.0.0.1:4416/ping', timeout=5).status)"
```

Si può aspettare HTTP 200. eseguire questo all'interno del contenitore del lavoratore se è dove yt-dlp si svolge.

**Chiedere mweb media con il fornitore**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" \
  --extractor-args "youtube:player_client=mweb" \
  --extractor-args "youtubepot-bgutilhttp:base_url=http://127.0.0.1:4416" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

**Cosa cercare nel log**

```text
PO Token Providers: bgutil:http-2.0.2 (external)
Generating a gvs PO Token for mweb client via bgutil HTTP server
[download] 100%
```

La scoperta del fornitore, la generazione di token e il trasferimento dei media sono tre controlli separati.

| Risultati osservati | Risolto |
| --- | --- |
| `PO Token Providers: none` | Il plugin non è caricato. installarlo con lo stesso interprete Python; rimuovere --no-plugin-dirs. per binari indipendenti, utilizzare l'installazione del plugin documentato ZIP del fornitore invece di pip in un ambiente non correlato. |
| `Error reaching GET … /ping` | Inizia il provider o corregge base_url. Controlla dal processo di download, non solo il tuo browser laptop. |
| Il fornitore è elencato, ma nessuna generazione si verifica | Leggi gli errori del giocatore precedente. `LOGIN_REQUIRED` può fermare la richiesta prima della fase di token. Un plugin caricato non dimostra che è stato utilizzato. |
| Un token viene generato, poi bot/sign-in rifiuto | Move a session/network diagnosi. generare un token non autentica il browser account. |
| mweb il token funziona, il vecchio cliente forzato ancora fallisce | Non riutilizzare il token di mweb per quel altro cliente. Lascia che il fornitore gesti il contesto selezionato, o ritorna alla configurazione del cliente lavorativo. |

Per due contenitori, `127.0.0.1` all'interno del lavoratore si riferisce al lavoratore stesso. Posare entrambi i servizi sulla stessa rete Docker e utilizzare il nome del servizio del fornitore, ad esempio `http://bgutil-provider:4416`. Non esponere pubblicamente il porto del fornitore.

**Utilizzare un fornitore sulla rete Docker del lavoratore**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f ba -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" \
  --extractor-args "youtube:player_client=mweb" \
  --extractor-args "youtubepot-bgutilhttp:base_url=http://bgutil-provider:4416" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Il problema #17681 registra un fallimento manuale-tocen risolto passando a un fornitore. Contiene anche una successiva ripresa: trattare il lavoro di fissaggio come prova di quel fallimento del token, non dimostrare che ogni successivo 403 ha la stessa causa.

- [Produttore di installazione e verifica](https://github.com/Brainicism/bgutil-ytdlp-pot-provider)
- [Context di token e attuali esigenze dei clienti](https://github.com/yt-dlp/yt-dlp/wiki/PO-Token-Guide)
- [Incidente di Tocco manuale: #17681](https://github.com/yt-dlp/yt-dlp/issues/17681)

<a id="formats"></a>

## Avanzato: un formato, clip o live stream fallisce


Il formato di lista con le stesse cookie, fornitori e opzioni di rete come il fallito download. Eseguire il formato fallito direttamente. Se un formato disponibile funziona diversamente, hai ridotto il fallimento a un percorso delivery/client; non hai stabilito che ogni risoluzione o codec sia rotto.

**Elenco dei formati per questo contesto richiesta**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -F "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

**Testare l'ID fallito da questa lista**

```bash
python -m yt_dlp --ignore-config --js-runtimes deno --impersonate="" --verbose --no-playlist \
  -f YOUR_FORMAT_ID -o "diagnostics/%(id)s-%(epoch)s.%(ext)s" \
  "https://www.youtube.com/watch?v=jNQXAC9IVRw"
```

Sostituisci YOUR_FORMAT_ID. Per una selezione combinata, prova separatamente i video e gli audio ID. Per un clip, prima prova un flusso non tagliato.

Gli avvertimenti di SABR riguardano i formati offerti da un cliente. Non è la stessa cosa di un fallimento n-challenge. Se un vecchio `web` override produce solo unavailable/unsupported formati, rimuovere il override o utilizzare la via documentata mweb/provider. Non aggiungere `formats=missing_pot` come un fisso: esponde i formati senza fornire il loro token mancante.

I video in diretta, recentemente terminati e ordinari caricati possono esponere diversi manifesti. Includere lo stato quando si cerca upstream. Se un flusso di recente terminato è ancora in fase di elaborazione, un formato alternativo attualmente disponibile o un'estrazione successiva può essere utile il prossimo test; aggiungere un codec globale di sovrappeso a ogni lavoratore non è.

- [Modifica del formato SABR: #12482](https://github.com/yt-dlp/yt-dlp/issues/12482)
- [Il rapporto post-live 403 è: #15586](https://github.com/yt-dlp/yt-dlp/issues/15586)

<a id="batch-recovery"></a>

## Riflessioni su Un lavoratore


In primo luogo, ripetere la fonte fallita con la produzione richiesta originale video/audio. Poi riprendere un lavoratore utilizzando la politica manifesto, archivio e di uscita esistente. Se tutti i lavori condividono la stessa sessione o la stessa rotta fallita, riposa che cammina piuttosto che moltiplicare i suoi fallimenti.

**Applicare pacing alla tua configurazione di raccolta esistente**

```bash
python -m yt_dlp --ignore-config --config-locations yt-dlp-work.conf -t sleep --retries 3 \
  --fragment-retries 3 --batch-file urls.txt
```

Utilizzare la configurazione che contiene ora funzionanti orari, fornitori, opzioni di produzione e archiviazione. il sonno premette le richieste spaziali all'interno di questo processo; non coordina altri lavoratori.

Un 403 tornato su ogni tentativo ha bisogno di una condizione cambiata prima di ritirarsi. Non impostare infinite retrazioni di fragmenti o spostare ID falliti nell'archivio di successo. Se i media sono finiti e solo la consegna di archiviazione non è riuscita, riprendere l'invio del file salvato.

- [Configurazione di raccolta reutilizzabile](https://flashdata.dev/it/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)
- [Python completamento e batch record](https://flashdata.dev/it/docs/guides/yt-dlp-python-api/reference.md#completion)

<a id="report"></a>

## Fare un utile errore? - Fare un utile errore


- Ricevere il trasferimento fallito reale con --verbose, non solo una corsa di successo --simulate.
- Mantenere la revisione yt-dlp, runtime/EJS versioni, il fornitore caricato e il selezionato format/protocol.
- Include l'avvertimento prima dell'errore, se un token è stato richiesto e se l'errore è avvenuto prima o dopo la selezione dei media.
- Ricordate i risultati della stessa fonte su IPv4/direct/proxy solo per le confronti che effettivamente avete fatto.
- Rimuovere i contenuti dei cookie, le credenziali proxy, gli URL firmati e i token prima di condividere il log.

Cerca upstream utilizzando l'avvertimento specifico precedente e il tuo rilascio. Se una regressione di corrispondenza è ancora aperta, mantenere l'articolo fallito e utilizzare un percorso di lavoro confermato mentre traccia che ripara. Un logo pulito che dice solo '403' è meno utile che un breve record che mostra il quale richiesta e cambiamento controllato non è riuscito.

- [Scopri i problemi di upstream](https://github.com/yt-dlp/yt-dlp/issues)
- [Bot-check e cookie di risoluzione](https://flashdata.dev/it/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Scarica i download di YouTube](https://flashdata.dev/it/products/youtube-download)
