# Corriger l’erreur 403 Forbidden de yt-dlp

Mettez à jour la version nightly, réduisez les requêtes simultanées, vérifiez Deno, puis testez les cookies et une adresse IP de sortie fonctionnelle.

Référence canonique : https://flashdata.dev/fr/docs/guides/yt-dlp-403-forbidden
Vérifié le 2026-11-13 par FlashData

- [Défaillance après le travail](https://flashdata.dev/fr/docs/guides/yt-dlp-403-forbidden/reference.md#versions) — Mettre en place le processus réel à la nuit
- [Faillite à mesure que la concurrence augmente](https://flashdata.dev/fr/docs/guides/yt-dlp-403-forbidden/reference.md#rate) — Réduire les processus, les fragments et les connexions
- [Cette IP proxy ne fonctionne pas](https://flashdata.dev/fr/docs/guides/yt-dlp-403-forbidden/reference.md#environment) — Test et maintient une route de sortie de remplacement
- [Avertissement de courant ou de token](https://flashdata.dev/fr/docs/guides/yt-dlp-403-forbidden/reference.md#challenges) — Vérifiez d'abord le détail, puis le contexte de la marque

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

## Premiers contrôles


1. **Mettez à jour la version nightly.** Utilisez l’environnement Python du processus qui échoue.
2. **Réduisez la charge.** Suspendez les tâches parallèles sur cette IP et testez une seule vidéo et un seul fragment à la fois.
3. **Vérifiez Deno.** Confirmez que le journal détaillé détecte le moteur JavaScript.
4. **Essayez des cookies valides.** Pour un petit lot, utilisez une session de navigateur qui peut lire la vidéo source.
5. **Remplacez l’IP refusée.** Relancez l’extraction via un hôte ou un proxy dont l’IP de sortie fonctionne.

**Mise à jour, puis vérifier le temps de fonctionnement requis**

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

**Une source, un transfert de faible charge**

```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"
```

Utilisez votre URL échoué, puis un court vidéo public comme contrôle. Cette sonde audio-uniquement évite FFmpeg et sauvage un nouveau nom de fichier timidité pour chaque tentative.

**Run sur le processus qui échoue.** Vérifiez la verbouse `Proxy map` pour son itinéraire réel. `--ignore-config` supprime les options sauvegardées mais maintient les plugins et les proxy environnementaux installés.

**Success signifie un fichier sauvé.** Une fois que l'audio fonctionne, testez la vidéo avec `-f bv`, puis restaurez vos paramètres de sortie complets. `--simulate` et `-F` ne testez pas un transfert de médias. Le cap `2M` est un point de départ pour le diagnostic.

- [Installation Linux : Nocturne, Deno et curl-cffi](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#install)
- [Erreur de check-in / check-in](https://flashdata.dev/fr/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [HTTP 429 limites de taux](https://flashdata.dev/fr/docs/guides/yt-dlp-429-too-many-requests/reference.md)

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

## 1 Actualiser à la nuit


**Un commandement précédemment fonctionnant échoue soudainement:** mise à jour d'abord. les changements de lecteur YouTube peuvent briser les extracteurs plus anciens; les derniers nuits peuvent déjà contenir la fixation.

**Mise à jour de l'environnement Python du processus**

```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__)"
```

**Si vous utilisez le fonctionnel exécutable au lieu**

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

yt-dlp -U seules mises à jour dans le canal actuel. Utilisez --update-to de nuit pour passer de stable.

Récupérer et redémarrer un conteneur si son image contient un paquet plus ancien; la mise à jour de Python sur l'hébergement ne met pas à jour ce conteneur. Gardez la révision exacte dans le journal de travail et rattachez la même source à nouveau avant de changer d'autres paramètres.

Retirez les anciens player_client, player_js_version et les formats=missing_pot surrides pour la base. Un processus d'un ancien incident peut désormais sélectionner un client inapproprié ou exposer un courant dont le token est encore manqué. Le sujet #14680 est un exemple d'un changement de joueur fixé en haut; copier son surride temporaire indéfiniment n'est pas le fix.

- [Réserver les canaux et les mises à jour](https://github.com/yt-dlp/yt-dlp#update)
- [Événement de changement de joueur : #14680](https://github.com/yt-dlp/yt-dlp/issues/14680)

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

## 2 Réduire les demandes concurrentielles


**Download fonctionne, puis échoue comme le volume augmente:** réduit la charge totale sur l'IP de sortie. dans l'expérience de FlashData, les transferts parallèles rapides peuvent déclencher le rejet.

| Source de charge | Première étape de diagnostic |
| --- | --- |
| Des emplois vidéo concurrents | Un vidéo actif pour cette sortie IP; arrêter le reste de la couverture temporairement. |
| Les demandes de fragment | --concurrent-fragments 1. |
| aria2 ou un autre téléchargement extérieur | Revenez à --downloader native. Si vous réactivez aria2 ensuite, commencez par -x 1 -s 1 -j 1. |
| Médias de bande-annonce | Essayez --limit-rate 2M comme un test conservateur, puis augmentez progressivement. |
| Extraction et nouveaux téléchargements | Utiliser --sleep-requests 2 et --sleep-interval 5 --max-sleep-interval 10. |
| Les retraites | Gardez les comptes de retraite à niveau de travail et de téléchargement limitées; ne les multipliez pas par rapport aux processus. |

**Retourner le flux vidéo requis à faible charge**

```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"
```

Si le transfert de faible charge fonctionne, maintenez cette base et augmentez une dimension à la fois tout en observant les échecs. Si elle échoue encore immédiatement après les vérifications nightly/runtime, ne continuez pas à réduire la bande passante indéfiniment: testez un autre IP de sortie. Une route déjà marquée par YouTube peut rester rejetée après que le trafic qui l'a déclenché ait cessé.

- [aria2 Contrôle de connexion](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#aria2)
- [Demande de pacing pour les métadonnées et captions](https://flashdata.dev/fr/docs/guides/yt-dlp-429-too-many-requests/reference.md#pacing)

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

## 3 – Vérifier le détail


**Vérifiez les deux dépendances sur le processus:** Deno mène les défis; `yt-dlp-ejs` fournit les scripts de solution. Le `[default]` extra installe les scripts. Installez Dino séparément.

**Vérifier les dépendances des processus**

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

**Vérifier la détection du temps de fonctionnement et la solution au défi**

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

Lisez la ligne de fonctionnement JS pour Deno, et tout [jsc:deno] message résolvant. Un temps de fonctionnement manquant ou signature/n-challenge a besoin de corriger avant une autre grande fonction de téléchargement. Deno 2.3+ est le minimum actuel dans la documentation EJS en hausse; utilisez une version soutenue à jour.

**Linux avec Deno hors 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"
```

Remplacer /opt/deno/bin/deno avec l'exécutable réel. sur macOS ou Windows, utilisez le chemin de Deno absolu du processus au lieu.

Le curl-cffi supplémentaire permet --impersonate="". Il fournit des empreintes digitales de demande comme le navigateur; il ne remplacera pas Deno. Si le cible du navigateur n’est pas disponible, installez l’extra dans le même environnement Python. Si l'impersonnalisation introduit un échec sur une route de travail, comparez la demande identique sans la drapeau.

Après le contrôle de dépendance, la transmission réelle des médias est en cours. Si le nucléaire actuel relate encore un échec de résolution de signature pour le même joueur, sauvez l'ID du joueur et le message de résolution pour le problème de sortie. Si la solution réussit et que les médias reçoivent 403, continuez à session/IP les vérifications.

- [Résultats de la mise en place et EJS](https://github.com/yt-dlp/yt-dlp/wiki/EJS)
- [Développement Linux complet](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#install)

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

## 4. Essayez des cookies valides pour un petit travail


**Teste une session connue.** Confirme que le navigateur peut jouer la source exacte, puis essayez ses cookies avec le même commandement et la même route.

**Utilisez la session Firefox en fonctionnement**

```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"
```

**Utiliser une session exportée sur un processus sans tête**

```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"
```

Utilisez les cookies de format Netscape. Gardez le fichier privé et écrite pour ce travail; pour un secret de lecture, faites une copie par job.

Si les cookies sont chargés mais YouTube dit qu’ils ne sont plus valables, remplacez la session plutôt que de passer le même fichier à plusieurs reprises. Pour quelques vidéos, maintenir un login de navigateur peut être pratique. Pour une grande collection de vidéos publiques, trouver et refroidir de nombreuses sessions de navigateur n'est pas une stratégie d'échanges dépendante.

Pour le travail en masse, gérer un pool d'IPs de sortie proxy utilisables et rouler aux frontières du travail, avec un budget bas par demande IP. Gardez les cookies de compte pour les sources qui nécessitent réellement l’accès à un compte. Un changement d'IP ne permet pas l'accès à un vidéo privé ou non disponible.

- [Procédure d’exportation et de renouvellement des cookies](https://flashdata.dev/fr/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md#renew-session)
- [Les cookies écrits dans les conteneurs](https://flashdata.dev/fr/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md#server)

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

## 5. remplacer une IP de sortie rejetée


**Le même vidéo public, les mêmes paramètres, le résultat différent par IP:** remplacera la sortie échouée. FlashData voit beaucoup de persistants 403s causés par des IP proxy pauvres ou flagellés. La réinstallation yt-dlp ne réparera pas cette route.

1. Gardez la source, la révision nocturne, Deno, les cookies si nécessaire, et le sélectionneur de format identique.
2. Testez une sortie IP de remplacement avec une extraction fraîche et un transfert réel de médias.
3. Confirmez que le proxy a réellement changé son IP de sortie. Un nouveau nom d'hôte ou un identifiant de porte peut toujours conduire à la même sortie.
4. Gardez une session proxy à l'écart tout au long de l'extraction, de la génération de tokens et du transfert de médias.
5. Réservez ou refroidir la sortie échouée dans votre piscine.Router vers une autre sortie saine pour un nouveau emploi ou une retraite contrôlée.

**Test de session de remplacement proxy**

```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"
```

Remplacer un proxy de session réelle privée. le log verbouse peut exposer les crédits proxy; rédiger avant de partager.

**Comparer l'accès direct à l'hôte lorsque disponible**

```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"
```

Cela désactive les proxy environment/configured pour le test. Débarrassez-le lorsque l'hébergement ne peut pas accéder directement à YouTube.

**Comparer la route IPv4 de l'hôte**

```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"
```

Une route IPv4 fonctionnelle peut différer de la route IPv6 échouée. Avec un proxy, -4 ne sélectionne pas nécessairement la famille IP outbound du proxy.

| Résultat | Action suivante |
| --- | --- |
| La même source réussit sur un nouveau IP de sortie | Gardez cette route et sa base à faible charge. Quarantine la sortie échouée plutôt que de la retracer pour chaque vidéo. |
| Le changement de certificats proxy n’a pas d’effet | Vérifiez la politique d'entrée IP et de session réelle; le proxy peut toujours utiliser la même sortie. |
| Le lecteur fonctionne, les médias échouent uniquement par le proxy | Vérifiez l'accès à googlevideo.com et que les médias utilisent le même exit/session. |
| Une source échoue sur chaque route testée ; le contrôle fonctionne | Investigez cette source, le format et l'état en direct. Ne marquez pas l'ensemble de la piscine de proxy cassée d'un seul vidéo. |

- [Upstream network/IP et le diagnostic de demande-volume](https://github.com/yt-dlp/yt-dlp/issues/17103)

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

## Avancé: maintenir l'extraction et le transfert sur un seul IP


Un bug d'application commun est l'extraction `info['url']` sur une machine, le stockage dans un coffre, et le téléchargement plus tard ailleurs. Les URL de médias signés expirent et peuvent dépendre des adresses IP et de la demande. Un proxy rotating peut créer la même division même dans une seule application.

Veuillez consulter l'ID vidéo YouTube et les paramètres de sortie souhaités. Laissez le processus effectuer une extraction fraîche et télécharger ensemble. Si le processus utilise un proxy, gardez le même égrès par l'extraction du joueur, la génération de tokens et les demandes médiatiques. Demandez au fournisseur de proxy une session de décision plutôt que de rouler chaque demande HTTP.

**Mettre en place l'extraction et le transfert dans le même travail 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"])
```

Ceci est un téléchargement local direct; il n'a pas besoin de clé API. Ajouter vos options cookie/provider vérifiées uniquement si les tests antérieurs les nécessitent.

Si cela réussit pendant que `requests.get(saved_media_url)` ou un processus FFmpeg séparé échoue, vérifiez ce défaut: âge de l'URL, titres fournis par extracteur, cookies et égrès réel. Gardez les URL médiatiques hors des enregistrements de travail durables. Lorsque vous retirez les résultats d'extraction expirés, demandez des URL fraîches de l'ID vidéo original.

- [Explication de l'extrait d'URL](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>

## Avancé: identifier la demande échouée


**La séquence de la demande**

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

`-F` liste les formats extraits; `--simulate` s'arrête avant de sauvegarder les médias. Il ne prouve pas non plus que le courant sélectionné retournera des bytes. Si le journal atteint `Downloading 1 format(s)` et s'il échoue avec un média-data 403, changer le nom de fichier de sortie ou installer FFmpeg ne réparera pas cette demande HTTP.

Les profils de client YouTube tels que `mweb` et `web_safari` changent les demandes de réponse du joueur yt-dlp. Certaines réponses nécessitent une signature ou une transformation de n-paramètres; certaines demandes médias nécessitent également un GVS proof-of-original token. Un token PO pour la demande du joueur n'est pas échangeable avec un pour la livraison de médias ou les sous-titres.

| Loger la localisation | Interprétation |
| --- | --- |
| `Unable to download API page` / `Unable to download webpage` | Identifier ce hébergement avant de le traiter comme un échec de serveur médiatique. |
| `unable to download video data: HTTP Error 403: Forbidden` | La demande de médias sélectionnée a été refusée. Suivez les branches solver/token/route ci-dessous. |
| Les messages de retraite | Gardez l'erreur et le protocole de fragment; comparez un autre format disponible au lieu de retraire le même fragment à temps indéfiniment. |
| FFmpeg dit HTTP 403 en lisant un entrée | FFmpeg est capturer les médias à distance, par exemple pour un clip. Vérifier l'URL et le réseau passé à FFmpeg; ce n'est pas un erreur de codec local. |
| L’enregistrement de stockage retourne `AccessDenied` | Fixez l'accès bucket et retry qui vous télécharge, pas le téléchargement YouTube. |

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

## Avancé: installer un fournisseur PO-token


Utilisez cette branche lorsque les formats nécessaires sont éteints pour un token GVS manquant, ou votre token configuré est rejeté. Les tokens sont liés à un contexte client/request et peuvent être liés à l'ID vidéo. Un token copié pour un seul vidéo n'est pas une créativité réutilisable pour une couche entière. Utilisez un fournisseur pour générer le token pour la demande actuelle.

> **Un avertissement peut décrire un échappé**
> Si un autre client a déjà livré le fichier requis, un seul avertissement de client échoué n'est pas un téléchargement échoué. enquêtez-le lorsque le courant requis est manqué ou que la demande médiatique sélectionnée échoue.

Leur utilisation est suivie par bgutil 2.0.2. Il a deux parties: un plugin Python chargé par yt-dlp et un service JavaScript qui génère des tokens. Gardez les versions en harmonie lors de l'actualisation. Les exemples ci-dessous utilisent un service accessible sur le même hôte au port 4416.

**Installation du connecteur dans l'environnement Python de yt-dlp**

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

**Docker**

Pour yt-dlp, rentrer sur l'hébergement Docker. publier uniquement le port de reprise.


**Démarrer le fournisseur**

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


**Node sans Docker**

Il faut Git, Node 22+ et npm. Exécuter le dernier commandement dans un terminal séparé et la laisser fonctionner. Si la dossier existe déjà, utilisez votre chèque existant de la sortie correspondante.


**Créer et démarrer le fournisseur autochtone**

```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
```


**Vérifier le service de l'environnement du téléchargateur**

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

Espérez HTTP 200. Exécuter cela dans le conteneur du processus si c'est là où yt-dlp se déroule.

**Demande mweb médias avec le fournisseur**

```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"
```

**Que chercher dans le 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%
```

Ce sont des lignes courtes de notre fonctionnement local. la découverte du fournisseur, la génération de token et le transfert de médias sont trois vérifications distinctes.

| Résultat observé | Solution |
| --- | --- |
| `PO Token Providers: none` | Le plugin n'est pas chargé. installez-le avec le même interprète Python; supprimez --no-plugin-dirs. Pour les binaires indépendants, utilisez l'installation ZIP du plugin documenté du fournisseur au lieu de piper dans un environnement non lié. |
| `Error reaching GET … /ping` | Commencez le fournisseur ou corriger base_url. Vérifiez du processus de téléchargement, pas seulement votre navigateur portable. |
| Fournisseur enregistré, mais aucune génération ne se produit | Lire les erreurs de joueur précédentes. `LOGIN_REQUIRED` peut arrêter la demande avant la phase de token. Un plugin chargé ne prouve pas qu'il a été utilisé. |
| Un token est généré, puis bot/sign-in rejet | Mouvement à session/network diagnostic. Gérer un token ne fait pas l'authentification du compte de navigateur. |
| mweb le token fonctionne, le vieux client forcé échoue encore | Ne pas réutiliser le token mweb pour cet autre client. Laissez le fournisseur gérer le contexte sélectionné, ou retourner à la configuration client fonctionnant. |

Pour deux conteneurs, `127.0.0.1` à l'intérieur du processus point à l'ouvrier lui-même. Placez les deux services sur le même réseau Docker et utilisez le nom de service du fournisseur, par exemple `http://bgutil-provider:4416`. Ne pas exposer publicement le port du fournisseur.

**Utiliser un fournisseur sur le réseau Docker du processus**

```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"
```

Problème #17681 enregistre un échec de token manuel résolu en passant vers un fournisseur. Il contient également une récurrence ultérieure: traite la fixation de travail comme preuve de cette échec de token, pas la preuve que chaque 403 ultérieur a la même cause.

- [Installation et vérification du fournisseur](https://github.com/Brainicism/bgutil-ytdlp-pot-provider)
- [Contexts de token et exigences actuelles du client](https://github.com/yt-dlp/yt-dlp/wiki/PO-Token-Guide)
- [Résultats de l'incident de toquette manuelle : #17681](https://github.com/yt-dlp/yt-dlp/issues/17681)

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

## Avancé: un format, clip ou streaming en direct échoue


Les formats de liste avec les mêmes cookies, fournisseurs et options réseau que le téléchargement échoué. Exécuter le format échoué directement. Si un autre format disponible fonctionne, vous avez étendu l'échec à un delivery/client chemin; vous n'avez pas établi que chaque résolution ou codec est brisé.

**Liste des formats pour ce contexte de demande**

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

**Testez l'ID échoué de cette liste**

```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"
```

Remplacer YOUR_FORMAT_ID. Pour une sélection combinée, vérifiez les ID vidéo et audio séparément. Pour un clip, essayez d'abord un flux non coupé.

Les avis SABR concernent les formats proposés par un client. Ce n’est pas le même qu’un échec n-challenge. Si un ancien `web` surride ne produit que unavailable/unsupported formats, supprimez le surride ou utilisez le chemin documenté mweb/provider. Ne pas ajouter `formats=missing_pot` comme une fixation : il expose les formats sans fournir leur token manquant.

Les vidéos en direct, récemment terminées et téléchargées ordinaires peuvent exposer différents manifestes. Inclure cet état lors de la recherche de upstream. Si un courant récemment terminé est encore en cours de traitement, un format alternatif actuellement disponible ou une extraction ultérieure peut être le test suivant utile; ajouter un codec mondial surride à chaque processus n'est pas.

- [Modification du format : #12482](https://github.com/yt-dlp/yt-dlp/issues/12482)
- [Post-live 403 rapport : #15586](https://github.com/yt-dlp/yt-dlp/issues/15586)

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

## Résumé Un processus


Répétez d'abord la source échouée avec la sortie requise video/audio d'origine. Puis, rétablissez un processus en utilisant la politique manifeste, archivée et de sortie existante. Si tous les emplois partagent la même session ou route échouée, pause qui courut plutôt que de multiplier ses échecs.

**Applicez le pacing à votre configuration de collection existante**

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

Utilisez la configuration qui contient les horaires de travail actuellement en cours, fournisseur, output et options d'archivage. le sommeil pré-établit les demandes d'espace dans ce processus; il ne coordonne pas d'autres processus.

Un 403 retourné sur chaque tentative a besoin d'une condition changée avant de se retraire. Ne définissez pas les retours de fragments infini ou déplacez les identifiants échoués dans l'archive de succès. Si les médias sont terminés et que la livraison de stockage n'a pas été effectuée, reprenez le chargement du fichier sauvé.

- [Configuration de collecte réutilisable](https://flashdata.dev/fr/docs/guides/how-to-use-yt-dlp/reference.md#repeatable)
- [Python completion et batch records](https://flashdata.dev/fr/docs/guides/yt-dlp-python-api/reference.md#completion)

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

## Pourtant échoué? préparer un rapport d'erreur utile


- C’est le cas de la réalité de la transition échouée avec --verbose, pas seulement un succès --simulate.
- Gardez la révision yt-dlp, runtime/EJS versions, fournisseur chargé et le fournisseur sélectionné format/protocol.
- Inclure l'alerte avant l'erreur, si un token a été demandé et si l'échec s'est produit avant ou après la sélection des médias.
- Résumez les résultats de la même source sur IPv4/direct/proxy seulement pour les comparaisons que vous avez réellement effectuées.
- Supprimer les contenus de cookies, les identifiants proxy, les URL signés et les tokens avant de partager le journal.

Recherchez upstream en utilisant l'avertissement précédent spécifique et votre libération. Si une régression correspondante est encore ouverte, conservez l'élément échoué et utilisez un chemin de travail confirmé tout en suivant ce recours. Un log propre qui dit seulement '403' est moins utile qu'un bref record qui montre lequel la demande et le changement contrôlé ont échoué.

- [Recherche de problèmes upstream](https://github.com/yt-dlp/yt-dlp/issues)
- [Bot-check et cookies fixes](https://flashdata.dev/fr/docs/guides/yt-dlp-sign-in-not-a-bot/reference.md)
- [Téléchargements YouTube gérés](https://flashdata.dev/fr/products/youtube-download)
