Interface en ligne de commande
Intégrez OpenShot dans votre flux de travail en ligne de commande. Importez des séquences, coupez et organisez les clips, appliquez des effets, animez les propriétés avec des images clés, et exportez des vidéos depuis votre terminal. Utilisez quelques commandes pour automatiser des montages répétitifs, écrire un script pour un projet récurrent, ou laissez un agent IA aider à assembler et affiner une vidéo.
La ligne de commande fonctionne avec les mêmes projets que l’éditeur. Vous pouvez contrôler un éditeur ouvert et revoir les modifications au fur et à mesure, ou travailler dans une session sans interface sans ouvrir de fenêtre. Une session garde votre projet ouvert entre les commandes, incluant ses modifications, l’historique des annulations, et les tâches d’exportation. Enregistrez-le en tant que projet .osp quand vous souhaitez continuer l’édition plus tard.
Premiers pas
Utilisez votre exécutable OpenShot installé suivi de --cli. Commencez par intro pour un guide rapide sur les sessions, l’édition, l’animation et l’enregistrement, ou help pour un aperçu des commandes. Ces commandes ne nécessitent pas de session active. Les exemples ci-dessous requièrent une version d’OpenShot incluant l’édition en ligne de commande.
Linux AppImage
Depuis le répertoire contenant votre AppImage téléchargée:
./OpenShot.AppImage --cli intro
./OpenShot.AppImage --cli help
Remplacez OpenShot.AppImage par le nom de fichier que vous avez téléchargé. Si AppImageLauncher affiche des dialogues d’intégration au bureau, définissez APPIMAGELAUNCHER_DISABLE=1 avant de lancer la commande:
APPIMAGELAUNCHER_DISABLE=1 ./OpenShot.AppImage --cli intro
Pour les scripts ou commandes répétées, définissez-le une fois dans votre shell actuel:
export APPIMAGELAUNCHER_DISABLE=1
./OpenShot.AppImage --cli session start
La variable doit être définie avant de lancer l’AppImage : AppImageLauncher peut l’intercepter avant qu’OpenShot ne reçoive --cli. Les chemins relatifs des médias et les fichiers @batch.json sont résolus depuis votre répertoire de travail. Gardez le fichier AppImage disponible tant que ses sessions ou exports sont en cours.
Linux Snap
Pour le OpenShot Snap, utilisez:
snap run openshot-qt --cli intro
snap run openshot-qt --cli help
snap run openshot-qt --cli session start
Les permissions de fichiers Snap s’appliquent aussi à l’édition en ligne de commande. Gardez les médias, projets et exports dans des emplacements accessibles par Snap, comme votre dossier personnel. Pour autoriser l’accès aux disques externes, connectez la permission removable-media:
sudo snap connect openshot-qt:removable-media
Windows
Important
Utilisez openshot-qt-cmd.exe pour l’édition en ligne de commande sous Windows. Cet exécutable console affiche les résultats des commandes, l’aide et les erreurs dans votre terminal. L’exécutable de bureau, openshot-qt.exe, n’affiche pas la sortie standard dans un terminal interactif, laissant les commandes sans retour visible et rendant la CLI difficile à utiliser.
Dans PowerShell, depuis le répertoire d’installation d’OpenShot:
& .\openshot-qt-cmd.exe --cli intro
& .\openshot-qt-cmd.exe --cli help
& .\openshot-qt-cmd.exe --cli session start
Si vous êtes dans un autre répertoire, utilisez le chemin complet vers openshot-qt-cmd.exe. Gardez --cli après le nom de l’exécutable.
macOS
Pour une installation dans Applications:
"/Applications/OpenShot Video Editor.app/Contents/MacOS/openshot-qt" --cli intro
"/Applications/OpenShot Video Editor.app/Contents/MacOS/openshot-qt" --cli help
Trouver les commandes
Dans ce guide, openshot-cli est une abréviation pour la commande de votre installation ci-dessus, comme snap run openshot-qt --cli ou ./OpenShot.AppImage --cli. Certaines installations fournissent aussi directement une commande openshot-cli. Lors de l’exécution depuis les sources, utilisez python3 src/launch.py --cli dans l’environnement Python d’OpenShot.
Les commandes --cli, --cli help et --cli --help affichent le même aperçu. L’aide devient plus spécifique au fur et à mesure que vous naviguez dans les commandes:
openshot-cli clip help
openshot-cli clip keyframe help
openshot-cli clip keyframe set help
openshot-cli edit help
openshot-cli text help
openshot-cli effects list
openshot-cli effects audiovisualization help
openshot-cli effects audiovisualization help --property background
L’aide de groupe explique les flux de travail avec des exemples ; l’aide d’opération décrit les arguments et le comportement. --help équivaut à help en fin de commande. Toutes les commandes d’aide fonctionnent sans session d’édition.
effects list affiche les effets disponibles avec de courtes descriptions. L’aide des effets explique leurs propriétés, valeurs par défaut, choix et plages. effects instances liste les effets déjà attachés aux clips, avec les ID des clips parents. Les noms de classe, noms d’affichage et alias avec underscore identifient le même effet.
Travailler avec des scripts et agents IA
Les agents de codage IA tels que Codex et Claude Code peuvent utiliser la CLI pour inspecter et éditer des projets OpenShot via des commandes terminal. Donnez à votre agent le chemin vers votre exécutable OpenShot, les médias ou projet à traiter, et le résultat souhaité : durée, dimensions, style d’animation, et emplacement de sortie. Demandez-lui de lire --cli intro avant de commencer. Les mêmes commandes fonctionnent que vous les tapiez vous-même ou les exécutiez depuis un script.
Commencez par intro, puis utilisez l’aide spécifique aux commandes selon les besoins. Un flux de travail utile consiste à sélectionner une session, inspecter le projet, effectuer un petit ensemble de modifications, revoir le résultat, et enregistrer. Les commandes renvoient du JSON structuré pour que les scripts et agents puissent utiliser directement les ID d’objets et résultats au lieu d’interpréter la sortie écran.
Inspectez avant d’éditer. Utilisez les ID retournés et les informations de propriétés au lieu de deviner les noms, numéros de piste ou timings. Sélectionnez explicitement une session quand plusieurs projets sont ouverts.
Regroupez les modifications répétées. Utilisez
edit applypour une séquence de changements ouedit bulkpour appliquer un modèle aux clips sélectionnés. Validez avec--dry-runavant d’appliquer un lot.Vérifiez l’animation. Choisissez un espace de coordonnées, commencez avec quelques images clés, et utilisez des préréglages d’accélération pour un mouvement familier.
keyframe previewéchantillonne la courbe pour que vous puissiez repérer les pauses ou les sauts avant l’exportation. Examinez également le mouvement rendu ; une planche-contact seule ne peut pas montrer la sensation d’une animation.Enregistrez et suivez les exports. Enregistrez explicitement le projet et vérifiez le statut du travail d’export avant de considérer une sortie comme terminée. Si une requête expire, inspectez son statut avant de répéter une modification.
Les sections ci-dessous expliquent ces flux de travail et leurs conventions de synchronisation.
Sessions et sorties
Démarrer ou trouver une session
Démarrer une session sans interface (sans fenêtre d’éditeur) :
openshot-cli session start
Pour ouvrir un projet existant au démarrage, ajoutez --project "/chemin/projet.osp". La réponse JSON réussie contient result.session_id. Copiez cette valeur. Si OpenShot est déjà en cours d’exécution, ou si vous avez oublié l’ID, trouvez les sessions disponibles avec:
openshot-cli session list
Choisissez la session pour le projet que vous souhaitez éditer. Vous n’avez pas besoin de démarrer une nouvelle session pour chaque commande.
Sélection d’une session
Astuce
Définissez OPENSHOT_SESSION une fois, puis exécutez les commandes normalement. Votre terminal se souvient de la session sélectionnée, vous n’avez donc pas besoin de passer --session à chaque commande. Utilisez l’exemple PowerShell ou Bash ci-dessous.
Remplacez SESSION_ID ci-dessous par le session_id retourné par session start ou session list.
Windows PowerShell :
$env:OPENSHOT_SESSION = "SESSION_ID"
& .\openshot-qt-cmd.exe --cli timeline view
& .\openshot-qt-cmd.exe --cli export start "C:\path\test.mp4" --wait
Linux Bash :
export OPENSHOT_SESSION="SESSION_ID"
./OpenShot.AppImage --cli timeline view
./OpenShot.AppImage --cli export start "/path/test.mp4" --wait
Sur macOS, utilisez la même syntaxe export. Pour les commandes macOS ou Snap, remplacez par l’exécutable de votre installation indiqué dans Premiers pas. La sélection dure pour ce terminal et les commandes lancées depuis celui-ci. Redéfinissez-la dans un nouveau terminal, ou mettez-la à jour lors du changement de session.
Les exemples d’édition et d’export restants supposent que OPENSHOT_SESSION est défini. La sous-section suivante montre comment capturer automatiquement l’ID pour les scripts.
Pour cibler une session différente pour une seule commande, utilisez --session. Cela remplace OPENSHOT_SESSION sans changer la sélection de votre terminal :
openshot-cli --session OTHER_SESSION_ID project get
Avec un exécutable packagé, placez cette substitution après --cli et avant le groupe de commandes : --cli --session OTHER_SESSION_ID project get.
La sélection automatique ne fonctionne que lorsqu’il existe exactement une session accessible. Si vous voyez session_required, exécutez session list et sélectionnez explicitement la session souhaitée. Si elle n’est plus listée, redémarrez-la et utilisez le nouvel ID. L’aide, intro et la découverte des sessions ne nécessitent pas de session sélectionnée.
Capturer automatiquement l’ID de session
Les scripts peuvent lire result.session_id directement depuis le JSON retourné par session start et définir OPENSHOT_SESSION pour les commandes suivantes. Il n’est pas nécessaire de copier manuellement l’ID ou de lire un fichier journal. Vérifiez que le démarrage a réussi avant d’utiliser l’ID retourné.
Windows PowerShell (définissez le chemin de l’exécutable pour votre installation) :
$openshot = "C:\Program Files\OpenShot Video Editor\openshot-qt-cmd.exe"
$reply = & $openshot --cli session start
if ($LASTEXITCODE -ne 0) { throw "OpenShot session startup failed" }
$session = $reply | ConvertFrom-Json
if (-not $session.ok -or -not $session.result.session_id) {
throw "OpenShot did not return a session ID"
}
$env:OPENSHOT_SESSION = $session.result.session_id
& $openshot --cli timeline view
Linux Bash (requiert jq pour lire le JSON) :
openshot="/full/path/to/OpenShot.AppImage"
export APPIMAGELAUNCHER_DISABLE=1
if reply=$("$openshot" --cli session start) &&
session_id=$(printf '%s' "$reply" | jq -er 'select(.ok == true) | .result.session_id | strings | select(length > 0)'); then
export OPENSHOT_SESSION="$session_id"
"$openshot" --cli timeline view
else
echo "OpenShot session startup failed" >&2
fi
La variable d’environnement sélectionne une session pour les commandes lancées depuis ce terminal ; elle ne modifie pas un paramètre système global. Démarrer une session ne définit pas automatiquement la variable. Après avoir arrêté la session, effacez la sélection avec Remove-Item Env:OPENSHOT_SESSION dans PowerShell ou unset OPENSHOT_SESSION dans Bash.
Afficher et arrêter une session
Pour afficher la session sélectionnée dans l’éditeur :
openshot-cli session show
Sur un bureau, session show crée l’éditeur dans le même processus et conserve le projet en cours, les IDs, l’historique, les travaux d’export et la connexion. Les appels répétés font apparaître la fenêtre existante. session start --show l’ouvre immédiatement. Les sessions démarrées sans affichage, ou avec QT_QPA_PLATFORM=offscreen/minimal, ne peuvent pas afficher une fenêtre de bureau par la suite. Pour ces sessions, enregistrez et ouvrez le projet dans une nouvelle session de bureau. Une fois affichée, fermez la session via la fenêtre de l’éditeur.
Les options globales (--session, --timeout) précèdent la commande. session serve reste au premier plan pour les superviseurs ; session start retourne après l’enregistrement d’un hôte en arrière-plan. session stop refuse les modifications non enregistrées et les exports actifs. Utilisez --discard uniquement pour abandonner intentionnellement des modifications non enregistrées.
Sortie de commande
Les résultats sont en JSON sur stdout, sauf la vue par défaut de la timeline en texte. Les erreurs sont en JSON sur stderr avec un code de sortie 1 ; les erreurs du parseur d’arguments ont un code de sortie 2. Les mutations retournent des résumés compacts avec une commande inspect. get retourne un JSON d’objet natif. Les réponses de projet incluent une révision ; les réponses du catalogue d’effets ne nécessitent pas de session. Les journaux des sessions sans interface résident à côté de leurs enregistrements dans le registre. OPENSHOT_SESSION_DIR remplace le répertoire par défaut ~/.openshot_qt/sessions.
Les sessions acceptent des commandes localement sur votre ordinateur. Gardez le registre des sessions privé, car il contient les identifiants utilisés pour accéder à vos sessions de montage. Les exportations fonctionnent à partir d’un instantané, vous permettant ainsi de continuer à monter pendant qu’un travail s’exécute.
Ouverture et sauvegarde des projets
Un projet OpenShot (.osp) stocke votre timeline éditable. L’exportation crée une vidéo finale ; sauvegarder le projet vous permet de revenir plus tard à ses clips, effets et images clés. Sauvegardez votre projet séparément même lorsque vous exportez également une vidéo.
Ouverture d’un projet
Démarrez une session avec un projet existant:
openshot-cli session start --project "/home/me/Videos/My Project.osp"
Ajoutez --show pour ouvrir également sa fenêtre d’éditeur. Pour utiliser un éditeur déjà en cours d’exécution, trouvez-le avec session list. Définissez OPENSHOT_SESSION sur l’ID de session retourné, puis ouvrez ou inspectez un projet:
openshot-cli project open "/home/me/Videos/My Project.osp"
openshot-cli project get
Remplacez le chemin d’exemple par le vôtre, et mettez entre guillemets les chemins contenant des espaces. project open remplace le projet actuel de la session sélectionnée. Il refuse de supprimer les modifications non sauvegardées à moins que vous n’ajoutiez explicitement --discard ; sauvegardez d’abord ces modifications si vous souhaitez les conserver. L’ouverture via la CLI ne montre pas les dialogues interactifs de médias manquants, gardez donc les médias sources du projet disponibles.
Pour un nouveau projet vide, utilisez session start sans --project, puis importez les médias et ajoutez des clips comme décrit dans la section Montage.
Sauvegarde d’un projet ou d’une copie
Sauvegardez dans un nouveau fichier, ou créez une version séparée avant de faire d’autres modifications:
openshot-cli project save "/home/me/Videos/My Project v2.osp"
Pour mettre à jour un fichier existant, autorisez explicitement le remplacement:
openshot-cli project save "/home/me/Videos/My Project v2.osp" --overwrite
Fournissez toujours le chemin de destination. Sauvegarder un fichier .osp ne regroupe pas toutes vos sources vidéo dans ce fichier ; gardez les médias référencés disponibles lors du déplacement ou de la réouverture du projet.
Exportation d’une vidéo
Automatisez le rendu et l’exportation depuis des scripts ou agents IA, en utilisant les paramètres du projet ou en choisissant un profil de sortie différent pour chaque rendu. Les tâches d’exportation peuvent s’exécuter en arrière-plan ou attendre la fin avant que votre script ne continue. Pour rendre un MP4 avec la résolution et la fréquence d’images du projet:
openshot-cli export start "/home/me/Videos/video.mp4" --wait
Par défaut, OpenShot utilise la vidéo H.264 et l’audio AAC. Remplacez le chemin d’exemple par votre destination, en utilisant un dossier existant et un nouveau nom de fichier. Les sorties existantes ne sont jamais écrasées. L’exportation ne sauvegarde pas votre projet éditable .osp ; utilisez project save séparément pour conserver votre travail de montage.
L’option --wait maintient la commande active jusqu’à ce que l’exportation soit terminée ou signale un échec. Vérifiez la vidéo finale avant de la partager.
Vérification de la progression de l’exportation
Ne pas utiliser --wait pour lancer une exportation en arrière-plan. La réponse inclut un ID de tâche que vous pouvez utiliser pour vérifier sa progression:
openshot-cli export start "/home/me/Videos/video.mp4"
openshot-cli export status JOB_ID
openshot-cli export status JOB_ID --wait
openshot-cli export list
Remplacez JOB_ID par l’ID retourné. Si le temps d’attente expire, l’exportation continue ; vérifiez la même tâche au lieu de lancer une autre exportation. Pour arrêter une tâche, utilisez export cancel JOB_ID. Chaque tâche capture la timeline au démarrage, donc les modifications ultérieures ne changent pas une exportation déjà en cours.
Le temps d’attente par défaut est de 600 secondes ; ajustez-le avec --wait-timeout. Ceci est distinct du --timeout global par requête. Les échecs d’exportation, annulations et expirations d’attente se terminent avec le statut 1 et incluent les détails de la tâche.
Exportation avec plusieurs profils
Exportez la même timeline à différentes résolutions ou rapports d’aspect en choisissant un profil d’export pour chaque sortie. Un profil d’export s’applique uniquement à cette tâche ; il ne modifie pas le profil du projet de montage. Un profil définit les dimensions, la fréquence d’images et le rapport d’aspect ; un préréglage d’export sélectionne les paramètres d’encodage tels que MP4/H.264.
Trouvez les profils disponibles et inspectez leurs paramètres:
openshot-cli profile list --search 720
openshot-cli profile list --search 1080
openshot-cli profile get builtin:01280x0720p0030_16-09
Par exemple, exportez des versions paysage en 720p et 1080p, puis une version carrée en 1080 par 1080. Ces profils utilisent tous 30 fps:
openshot-cli export start "/home/me/Videos/video-720p.mp4" --profile builtin:01280x0720p0030_16-09 --wait
openshot-cli export start "/home/me/Videos/video-1080p.mp4" --profile builtin:01920x1080p0030_16-09 --wait
openshot-cli export start "/home/me/Videos/video-square.mp4" --profile builtin:01080x1080p0030_01-01 --wait
Utilisez un nom de fichier de sortie différent pour chaque version. Gardez les modifications inchangées entre les tâches lorsque vous souhaitez des versions correspondantes. Changer le rapport d’aspect peut modifier le cadrage : vérifiez chaque sortie, en particulier les titres et sujets animés. Pour une version carrée ou portrait composée séparément, sauvegardez une copie du projet, changez son profil de projet et ajustez les clips avant d’exporter. Consultez Profils et les paramètres d’export ci-dessous pour les profils personnalisés et options d’encodage.
Exportation par lots de plusieurs projets
Réutilisez une session sans interface pour rendre plusieurs projets sauvegardés en séquence. Ouvrez un projet, exportez-le avec --wait, puis ouvrez le projet suivant. Les exemples ci-dessous utilisent la résolution et la fréquence d’images propres à chaque projet et créent des fichiers MP4 à côté des fichiers .osp. Ajoutez --profile PROFILE_ID à la commande d’export pour utiliser un profil de sortie unique pour chaque projet.
Exécutez d’abord avec succès l’exemple d’ID de session automatique correspondant ci-dessus, dans le même terminal. Il définit openshot et sélectionne la nouvelle session. Remplacez les chemins de projet ci-dessous par les vôtres. Utilisez des noms de sortie distincts qui n’existent pas déjà ; les exemples vérifient toutes les destinations avant de démarrer le lot.
Windows PowerShell :
$projects = @(
"C:\VideoProjects\First.osp",
"C:\VideoProjects\Second.osp"
)
foreach ($project in $projects) {
if (-not (Test-Path -LiteralPath $project -PathType Leaf)) {
throw "Project not found: $project"
}
$output = [System.IO.Path]::ChangeExtension($project, ".mp4")
if (Test-Path -LiteralPath $output) { throw "Output already exists: $output" }
}
foreach ($project in $projects) {
$output = [System.IO.Path]::ChangeExtension($project, ".mp4")
& $openshot --cli project open $project
if ($LASTEXITCODE -ne 0) { throw "Could not open: $project" }
& $openshot --cli export start $output --wait --wait-timeout 86400
if ($LASTEXITCODE -ne 0) { throw "Export needs attention: $output" }
}
& $openshot --cli session stop
if ($LASTEXITCODE -ne 0) { throw "Could not stop the session" }
Remove-Item Env:OPENSHOT_SESSION
Linux Bash (les parenthèses maintiennent la gestion des erreurs locale au lot)
(
set -e
: "${OPENSHOT_SESSION:?Run the session startup example first}"
projects=(
"/home/me/VideoProjects/First.osp"
"/home/me/VideoProjects/Second.osp"
)
for project in "${projects[@]}"; do
test -f "$project" || { echo "Project not found: $project" >&2; exit 1; }
output="${project%.osp}.mp4"
test ! -e "$output" || { echo "Output already exists: $output" >&2; exit 1; }
done
for project in "${projects[@]}"; do
"$openshot" --cli project open "$project"
"$openshot" --cli export start "${project%.osp}.mp4" --wait --wait-timeout 86400
done
"$openshot" --cli session stop
) && unset OPENSHOT_SESSION
Les deux recettes arrêtent le lot en cas d’échec d’une commande et laissent la session disponible pour inspection. La limite d’attente ici est de 24 heures par exportation. Un délai d’attente laisse le rendu en cours : utilisez export list et export status JOB_ID --wait avant de réessayer. Les vidéos terminées restent sur le disque ; supprimez les projets terminés du lot avant de reprendre. Après avoir résolu une erreur, arrêtez la session et effacez sa variable d’environnement lorsque vous avez terminé.
Choisir les préréglages et les paramètres d’encodage
Découvrez les préréglages d’exportation installés et les paramètres pris en charge
openshot-cli export preset list
openshot-cli export preset get builtin:format_mp4_x264
openshot-cli export capabilities
openshot-cli export start /tmp/reel.mp4 --preset builtin:format_mp4_x264 --quality med --wait
Export accepte également --from-file FILE_ID avec l’option --create-custom. Les paramètres se résolvent dans cet ordre : valeurs par défaut du projet, préréglage, JSON avancé, indicateurs explicites de profil/qualité/plage. Le JSON avancé expose les codecs vidéo/audio et le débit binaire, la disposition/taux/canaux audio, les options de codec natif, les paramètres du matériel et le nombre de threads.
Par exemple, sélectionnez une option d’encodeur via le JSON avancé
openshot-cli export start /tmp/small.mp4 --profile builtin:00640x0360p0030_16-09 --json '{"video_options":{"preset":"fast"}}' --wait
Validation des paramètres d’exportation
Vérifiez les paramètres avant de lancer un rendu
openshot-cli export validate /tmp/reel.mp4 --preset builtin:format_mp4_x264
Le rapport de capacités indique la disponibilité des codecs compilés, pas la disponibilité physique du GPU. La validation va plus loin : elle ouvre les encodeurs (y compris matériels) et le conteneur avec les paramètres exacts, dans un processus séparé, sans écrire de fichier. Une combinaison que le conteneur ne peut pas contenir échoue avec incompatible_export, l’explication propre à FFmpeg, et le paramètre à modifier (details.cause.path)
openshot-cli export validate /tmp/song.mp3 --json '{"mode":"audio","format":"mp3","audio_codec":"aac"}'
Le processus d’exportation effectue la même vérification avant le rendu.
Rendu d’une plage d’images
Utilisez --start-frame et --end-frame pour rendre une partie de la timeline. Les plages sont inclusives et basées sur 1 selon la fréquence d’images (FPS) du profil d’exportation. Par exemple, rendez les 90 premières images à 30 fps (trois secondes)
openshot-cli export start /tmp/excerpt.mp4 --profile builtin:01280x0720p0030_16-09 --start-frame 1 --end-frame 90 --wait
Exportations audio uniquement et séquences d’images
Choisissez un mode de sortie avec le JSON avancé
openshot-cli export start /tmp/music.wav --json '{"mode":"audio","format":"wav","audio_codec":"pcm_s16le"}' --wait
openshot-cli export start /tmp/frames --json '{"mode":"image_sequence","format":"png"}' --end-frame 3 --wait
Les séquences d’images nécessitent un nouveau répertoire de sortie. Les sorties existantes ne sont jamais écrasées.
Édition
Ajout de clips et d’effets
Utilisez les ID retournés par import/add/list, et découvrez les numéros de couche avec project get
openshot-cli file import /absolute/path/video.mp4
openshot-cli clip add FILE_ID --layer 2000000 --position 3 --start 10 --end 17 --volume 0
openshot-cli clip set CLIP_ID --json '{"volume":0.5}'
openshot-cli clip keyframe set CLIP_ID --property volume --frame 301 --value 0
openshot-cli clip keyframe set CLIP_ID --property volume --frame 331 --value 1
openshot-cli effects add CLIP_ID saturation
openshot-cli effects set EFFECT_ID --json '{"saturation":1.2}'
openshot-cli project save /absolute/path/edit.osp
Choisissez le profil du projet tôt lorsque c’est possible ; les projets peuplés supportent également les changements de profil via la conversion FPS existante et le système d’annulation. --audio-only lors de la création d’un clip supprime la vidéo, y compris la pochette intégrée dans les fichiers musicaux. Pour utiliser ce clip pour la visualisation audio à la place, activez sa vidéo et son audio, et suivez l’aide de l’effet pour les superpositions transparentes et le placement des couches.
Comprendre le timing des clips
Les images clés d’exemple supposent un projet à 30 fps et un clip coupé à 10 s source. La position est en secondes de timeline ; début/fin sont en secondes source, la fin étant exclusive. Les images commencent à 1. Les vignettes de fichiers utilisent la fréquence source. Les images de la timeline utilisent la fréquence du projet. Les images clés du clip utilisent les coordonnées source à la fréquence du projet, donc couper le clip ne déplace pas sa première image clé visible à l’image 1.
Modification des propriétés
set fusionne les propriétés de premier niveau. Les scalaires transforment les propriétés animées en constantes. Une courbe imbriquée fournie remplace cette courbe ; utilisez keyframe set pour modifier un seul point. Les arguments JSON acceptent du JSON en ligne, @file.json, ou - pour stdin. Les noms de propriétés, types, énumérations, images clés, références et timings sont validés avant la modification du projet. Les erreurs identifient le champ, la valeur attendue, la valeur reçue, et une correction si possible. Les plages des curseurs GUI sont indicatives lorsque le moteur supporte des valeurs au-delà.
Ajout de fondus
clip fade ID --in 0.5 --out 0.5 calcule automatiquement les coordonnées des images clés de découpe source. Il remplace la courbe alpha ; --property volume --value 0.25 crée à la place un fondu audio avec un gain maximal de 0,25. Les durées doivent s’inscrire entre la première et la dernière image visible ; le fondu de sortie atteint zéro à la dernière image.
Division des clips
clip split ID --at 6.5 utilise les secondes de la timeline, s’aligne sur l’image de projet la plus proche, et conserve les deux moitiés. Il conserve les courbes en coordonnées source et duplique les effets avec de nouveaux ID sur la moitié droite, suivant le comportement de découpage de l’éditeur. La moitié gauche conserve son ID. La réponse rapporte les temps de découpe demandés/réels et les deux résumés ; un résultat de lot nommé supporte {"$ref":"cut.right.id"}. Les découpes rejettent les points de fin et les pistes verrouillées. L’annulation restaure le clip original en une seule transaction.
Ajouter et styliser du texte
text add crée un texte et le place comme un clip, en utilisant le même texte que l’outil Texte de l’éditeur. Les options non spécifiées utilisent le style par défaut de l’éditeur :
openshot-cli text add --text "Opening Night" --layer 5000000 --position 2 --duration 4 \
--place lower-third --font "Noto Sans" --size 72 --bold --color "#ffffff" \
--background "#80000000" --background-padding 16 --background-corner 12
openshot-cli text get CLIP_ID
openshot-cli text set CLIP_ID --stroke black --stroke-width 3
openshot-cli text set CLIP_ID --text $'Two\nlines' --line-spacing 1.4
openshot-cli text fonts --search noto
openshot-cli text list --search opening
Les mots, la police, la taille, l’alignement, la largeur de la boîte et les couleurs par défaut appartiennent au texte dans les fichiers de projet et sont partagés par chaque clip qui l’utilise, comme dans l’éditeur. text set sur un clip modifie tous ces éléments et les liste dans changed_clip_ids ; --this-clip-only donne d’abord une copie propre à ce clip. clip add FILE_ID place un autre clip d’un texte issu de text list. Les tailles sont en pixels à la résolution du projet, et les couleurs sont #RRGGBB, #AARRGGBB (avec alpha), un nom CSS, ou transparent. --place positionne la boîte au centre, sur un bord ou un coin, ou dans un tiers inférieur. --line-spacing est un multiple de la distance normale entre les lignes (1 est normal), et --background-corner arrondit les coins du fond et de la bordure de ce nombre de pixels.
Un clip de texte est un clip ordinaire. La position, l’échelle, la rotation, l’opacité, le timing, les fondus, les préréglages de mouvement et les effets utilisent tous les commandes clip normales. La taille de la police, le rembourrage, la largeur de la boîte, ainsi que l’espacement des lettres et des lignes définissent la taille de la boîte de texte, ils ne peuvent donc pas être animés par images clés ; pour animer la taille du texte, animez l’échelle du clip. Chaque clip peut animer ses propres couleurs de texte ainsi que les largeurs du contour et de la bordure avec les mêmes commandes d’images clés que pour toute autre propriété :
openshot-cli clip keyframe list CLIP_ID
openshot-cli clip keyframe set CLIP_ID --property text_color.alpha --space clip --unit seconds --at 0 --value 0
openshot-cli clip keyframe set CLIP_ID --property text_color.alpha --space clip --unit seconds --at 1 --value 255
Les propriétés animées sont text_color, text_background, text_stroke et text_border (couleurs, avec .red, .green, .blue et .alpha de 0 à 255), ainsi que text_stroke_width, text_border_width et text_background_corner. L’animation propre d’un clip prévaut sur le style partagé, et text get liste les styles qu’un clip anime. text reset CLIP_ID ramène un clip au style par défaut, comme Texte → Réinitialiser le style ; --keyframes-only supprime uniquement l’animation propre du clip. Pour styliser plusieurs textes à la fois, sélectionnez-les avec {"text":true} :
openshot-cli edit bulk --select '{"text":true}' --json '[{"method":"text.set","params":{"font_family":"Noto Sans","stroke_width":2}}]'
Appliquer un lot de modifications
edit apply --json @edits.json --expect-revision 12 accepte jusqu’à 256 commandes de mutation ordonnées, utilisant des noms de commande pointés tels que clip.set et effects.add (l’ancienne orthographe effect.add fonctionne aussi) : :
[
{"method":"project.profile.set","params":{"id":"builtin:01280x0720p0024_16-09"}},
{"method":"file.import","as":"media","params":{"path":"/tmp/video.mp4"}},
{"method":"clip.add","as":"shot","params":{"file_id":{"$ref":"media.id"},"layer":1000000,"start":10,"end":15}},
{"method":"clip.fade","params":{"id":{"$ref":"shot.id"},"fade_in":0.5,"fade_out":0.5}}
]
L’optionnel as lie un résultat pour des commandes ultérieures dans le même lot. Un objet {"$ref":"shot.id"} substitue le champ de ce résultat. Les références ne résolvent que les noms antérieurs ; les fautes de frappe, références anticipées et noms en double échouent avant les mises à jour en direct. La réponse inclut des résultats compacts ordonnés et une carte refs des IDs réels. Tous les changements dans un lot réussi forment une seule étape d’annulation/rétablissement. project.profile.set supporte aussi les timelines peuplées. Les commandes d’ouverture, sauvegarde, exportation et inspection restent hors des lots d’édition. L’aide de chaque commande liste ses noms de paramètres JSON, y compris l’orthographe avec underscore des options shell (par exemple, --fps-num devient fps_num).
Validation des lots et gestion des erreurs
Toutes les commandes dans les lots d’édition sont prévalidées sur un projet détaché avant toute mise à jour en direct. Une entrée invalide laisse le projet en direct et la révision inchangés. Les lots valides forment un seul groupe d’annulation. Les échecs d’exécution inattendus peuvent encore produire des changements partiels ; les erreurs rapportent les opérations terminées. Un délai d’attente n’implique pas l’annulation, inspectez donc l’état avant de réessayer les mutations.
Édition précise des images clés
clip, transition et effects supportent keyframe list, set, remove, clear, transform, copy et paste. Les chemins de propriété peuvent adresser des courbes imbriquées, comme color.red sur un effet Chroma Key. L’édition d’une courbe imbriquée préserve les canaux frères. Exécutez keyframe list ID sans propriété pour découvrir les chemins de courbe et le nombre de points. La découverte et la liste des points incluent le contexte temporel de découpe/position ; la liste des points rapporte aussi les coordonnées natives des images. get et properties exposent l’objet natif complet et les métadonnées des propriétés. Les erreurs identifient les champs invalides, suggèrent des noms de propriété proches et expliquent les corrections de coordonnées.
Choisissez explicitement les coordonnées avec --space native|clip|timeline et --unit frames|seconds. Toutes les images utilisent le FPS du projet et sont indexées à partir de 1 ; les secondes commencent à zéro et s’alignent sur l’image la plus proche. Native est la coordonnée d’image clé existante du moteur (incluant la découpe source). Les coordonnées clip commencent au point d’entrée visible du clip ; les coordonnées timeline commencent à zéro dans le temps du projet. Les effets attachés utilisent le timing de leur clip parent. Ces coordonnées adressent le temps d’animation, pas les images médias sélectionnées par une courbe de remappage temporel.
Pour un clip positionné à 5 secondes, coupé à 2 secondes, dans un projet à 30 fps, la frame du clip 1, la frame de la timeline 151, et la frame native 61 correspondent au même point. La position et la coupe s’alignent indépendamment sur la grille des frames du projet. Lister une courbe entière peut inclure des points cachés avec des coordonnées clip/timeline non positives. L’option héritée --frame signifie toujours une frame native et ne peut pas être combinée avec --at.
Exemples:
openshot-cli clip keyframe set CLIP --property location_x --space clip --unit seconds --at 0 --value -1
openshot-cli clip keyframe set CLIP --property location_x --space clip --unit seconds --at 1 --value 0 --interpolation bezier --handles '{"handle_left":{"X":0.2,"Y":0.9}}'
openshot-cli effects keyframe set EFFECT --property color.red --space clip --at 31 --value 200
openshot-cli clip keyframe list CLIP --property location_x --space clip --unit seconds
openshot-cli clip keyframe transform CLIP --property location_x --space clip --start 1 --end 31 --scale 2 --offset 15
openshot-cli clip keyframe copy TARGET --property location_x --source-id SOURCE --space clip --start 1 --end 31 --at 1 --mode merge
openshot-cli clip keyframe remove CLIP --property location_x --space clip --at 31
openshot-cli clip keyframe clear CLIP --property location_x --value 0
Interpolation, lissage et aperçu
L’interpolation décrit le segment jusqu’au point de destination. Linéaire offre un taux constant entre les points. Constant maintient la valeur précédente jusqu’à la destination, puis saute. Les poignées Bezier natives par défaut facilitent la transition aux deux extrémités de chaque segment. Ajouter un point intermédiaire peut donc introduire un ralentissement non désiré ; pour un mouvement lissé, commencez avec deux points d’extrémité. Normalement, laissez les poignées telles quelles et choisissez un préréglage nommé pour un style spécifique.
Découvrez les mêmes préréglages de lissage utilisés par les menus de l’éditeur, sans session:
openshot-cli clip keyframe presets
Appliquez un préréglage au segment entrant en définissant sa destination:
openshot-cli clip keyframe set CLIP --property scale_x --space clip --unit seconds --at 0 --value 1
openshot-cli clip keyframe set CLIP --property scale_x --space clip --unit seconds --at 4 --value 1.2 --easing ease-in-out
L’option de lissage implique Bezier. Elle règle simultanément la poignée sortante du point précédent et la poignée entrante de la destination, en préservant les autres poignées et valeurs des points. Un point antérieur doit exister. Ne la combinez pas avec des poignées personnalisées ou une interpolation différente. Les préréglages fonctionnent par lots et modèles en masse. Le préréglage GUI ease (« Ease (Default) ») diffère des poignées natives utilisées par l’interpolation Bezier simple. Les préréglages de retour peuvent dépasser les valeurs des points d’extrémité.
Inspectez le mouvement avant le rendu, en utilisant l’évaluateur de courbe natif:
openshot-cli clip keyframe preview CLIP --property scale_x --space clip --unit seconds --start 0 --end 4
openshot-cli clip keyframe preview CLIP --property scale_x --space clip --unit seconds --at 2
L’aperçu est en lecture seule et fonctionne de manière identique pour les effets et les transitions. Il renvoie les valeurs ainsi que les taux entrants/sortants signés en unités de propriété par seconde, calculés à partir des frames immédiatement adjacentes. Ce sont des différences finies, pas des dérivées analytiques. À la frame native 1, le taux entrant est nul. Les taux des frames adjacentes peuvent inspecter en dehors de la plage demandée. Des taux proches de zéro autour d’un point intérieur révèlent une pause ; des taux différents révèlent un changement de vitesse. L’interpolation constante révèle un saut à la destination.
Sans plage, l’aperçu couvre les premier et dernier points de la courbe. Les plages sont inclusives, avec 17 échantillons espacés uniformément par défaut (–count : 2–256). Les images clés et leurs voisins immédiats à l’intérieur de la plage sont également inclus, donc un nombre d’échantillons faible ne masquera pas un arrêt d’image clé. Le maximum est de 1024 échantillons ; des demandes plus grandes nécessitent une plage plus étroite. –at échantillonne une frame. L’aperçu rapporte les coordonnées dans l’espace demandé et les frames natives réelles ; les secondes s’alignent sur les frames du projet comme pour le montage.
Pour les poignées personnalisées avancées, X et Y sont normalisés au segment : X est une fraction de son étendue en frames ; Y est une fraction de son changement de valeur. Le premier contrôle provient de la poignée droite du point précédent, le second de la poignée gauche de la destination. Les valeurs natives par défaut sont right=(0.5, 0), left=(0.5, 1), avec des tangentes plates aux extrémités. Changer uniquement le type de poignée ne recalcule pas une tangente continue à travers les points environnants. Les poignées existantes sont conservées lors du déplacement d’un point.
Les plages d’images clés sont inclusives, contrairement aux plages temporelles de sélection de clip. La commande list émet des points dont les valeurs co.X utilisent l’espace/unité de coordonnées demandé. Passez ce tableau à keyframe paste --json @points.json avec le même espace/unité, en choisissant --mode merge (remplacer les frames correspondantes, conserver les autres) ou --mode replace (remplacer toute la courbe). copy accepte une source du même type d’objet, une option --source-property, et ancre le premier point source sélectionné à --at sur la cible. Les autres courbes et objets source restent inchangés.
transform applique une échelle temporelle positive autour du premier point sélectionné, ou de --pivot, suivi d’un --offset signé dans l’unité choisie. L’alignement sur les frames qui crée des coordonnées dupliquées est rejeté, y compris les collisions avec des points hors de la plage sélectionnée. Les coordonnées natives doivent rester au moins à 1. Les poignées Bézier normalisées natives et l’interpolation se déplacent avec chaque point ; les poignées ne sont pas des coordonnées absolues de frame. set --handles modifie uniquement les poignées fournies. L’interpolation appartient au point de destination.
clear conserve un point de base constant à la frame native 1 : spécifiez --value ou échantillonnez la courbe existante avec --at (frame native 1 par défaut). Supprimer le dernier point conserve également une base constante, donc les ajouts d’images clés ultérieurs restent valides.
Sélection et édition de plusieurs clips
Utilisez edit apply --dry-run pour valider un lot sans modifier le projet. Utilisez edit bulk pour répéter un petit modèle de commande pour chaque clip sélectionné, avec toutes les modifications regroupées en une seule étape d’annulation.
Prévisualisez d’abord une sélection:
openshot-cli edit select --json '{"layer":1000000,"start":5,"end":20,"effect":"Saturation"}'
Les sélecteurs prennent en charge ids (tableau d’ID uniques de clip), layer, start/end (secondes sur la timeline), file_id, effect (nom de classe ou alias), et text (true sélectionne les clips texte). Les filtres se combinent avec ET. Les plages temporelles sélectionnent les clips chevauchant [start, end) ; ils ne rognent pas ces clips. Les résultats sont ordonnés par position, couche, puis ID, et incluent les IDs, résumés, état de verrouillage, et la révision actuelle. Les IDs inconnus sont des erreurs. Un sélecteur vide est rejeté ; utilisez explicitement {"all":true} pour chaque clip. Les sélections sont limitées à 256 clips et ne sont jamais tronquées silencieusement.
Par exemple, enregistrez ce tableau sous templates.json:
[
{"method":"clip.adjust","params":{"values":{"position":{"add":2},"volume":{"multiply":0.5}}}},
{"method":"effects.add","as":"look","params":{"type":"Saturation"}},
{"method":"effects.keyframe.set","params":{"id":{"$ref":"look.id"},"property":"saturation","space":"clip","at":1,"value":0}},
{"method":"effects.keyframe.set","params":{"id":{"$ref":"look.id"},"property":"saturation","space":"clip","at":31,"value":1.2}}
]
Validez-le, puis appliquez-le à la révision retournée par la sélection:
openshot-cli edit bulk --select '{"ids":["CLIP_A","CLIP_B"]}' --json @templates.json --dry-run
openshot-cli edit bulk --select '{"ids":["CLIP_A","CLIP_B"]}' --json @templates.json --expect-revision 42
Les commandes sur clips existants héritent de id ; effects.add hérite de clip_id. Omettez ces paramètres cibles dans les modèles. Les modifications d’effets doivent référencer un résultat nommé antérieur. Les noms sont locaux à chaque clip sélectionné, donc look.id fait référence à un effet différent pour chaque clip. Pour modifier des instances d’effets existantes par ID explicite, continuez à utiliser edit apply. L’ensemble d’IDs sélectionné est fixé avant l’expansion ; les changements de position ou d’effets ne modifient pas les cibles restantes.
clip set applique des propriétés absolues ; clip adjust applique multiply puis add à une propriété numérique ou à chaque valeur d’une courbe, en préservant le timing des points, l’interpolation et les poignées normalisées. Il valide les valeurs résultantes, y compris les positions non négatives et le volume. Les champs structurels restent protégés.
Les opérations en masse rejettent les sélections vides, les pistes cibles verrouillées, et plus de 256 commandes développées. Chaque opération développée passe un précontrôle détaché avant toute modification en direct. Les simulations n’allouent pas d’IDs générés. Utilisez --expect-revision pour rejeter les sélections obsolètes. Les lots réussis constituent une seule étape d’annulation, y compris après sauvegarde/réouverture. Les rafraîchissements de l’interface sont regroupés. Les erreurs inattendues d’exécution/écouteur peuvent encore laisser une transaction partielle ; l’erreur rapporte les opérations terminées et l’annulation rétablit ce groupe, comme avec edit apply.
Profils
Découvrez les profils et associez la vidéo importée sans deviner les IDs:
openshot-cli profile list --search 720
openshot-cli profile get builtin:01280x0720p0024_16-09
openshot-cli profile match --file FILE_ID
openshot-cli project profile get
openshot-cli project profile set --from-file FILE_ID
openshot-cli project profile set builtin:01280x0720p0024_16-09
openshot-cli project profile set --json '{"width":640,"height":352,"display_ratio":{"num":20,"den":11},"fps":{"num":24000,"den":1001}}'
Les entrées du catalogue incluent des IDs stables, descriptions, dimensions, FPS rationnel, rapports d’aspect, et paramètres de balayage. La liste/la recherche est paginée. L’association de source retourne des IDs exacts et des alternatives classées avec différences explicites. La configuration depuis un fichier nécessite une correspondance exacte sauf si --create-custom est spécifié ; elle ne choisit jamais silencieusement un profil proche. Les images fixes et sources audio seules ne peuvent pas définir un profil vidéo. L’association utilise le FPS source déclaré.
Les paramètres personnalisés sont intégrés dans le projet sauvegardé, y compris les taux rationnels, donc la réouverture ne nécessite pas l’installation d’un fichier de profil séparé. Les changements de profil de projet utilisent la conversion de fréquence d’images existante et une transaction d’annulation unique. Annuler/rétablir restaure le timing des clips et les images clés, y compris les positions sensibles à l’arrondi. L’export peut sélectionner indépendamment un profil sans changer le projet.
L’historique d’annulation sauvegardé suit la préférence de limite d’historique de l’éditeur. La limite est un budget d’action souple : tous les enregistrements appartenant aux transactions conservées sont gardés, donc la sauvegarde ne peut pas tronquer un grand lot en une action d’annulation partielle. Zéro désactive l’historique sauvegardé. La limite distincte de 256 commandes par lot s’applique toujours.
Inspection des médias et des timelines
Inspectez le timing des clips et la disposition des pistes en texte ou JSON, ou générez des images pour revoir la composition et le cadrage avant l’export.
Résumés de timeline
Utilisez une vue texte pour un aperçu rapide, ou un JSON structuré pour les scripts et agents:
openshot-cli timeline view --start 5 --end 12
openshot-cli timeline view --start 5 --end 12 --format json
openshot-cli timeline overview --start 5 --end 12
timeline view affiche par défaut un texte compact avec les pistes utilisées, IDs d’objets, intervalles timeline/source, état du flux, gain, et écarts/chevauchements. Utilisez --detail summary|clips|full pour choisir le détail, --format json pour un contexte structuré, et --start/--end, --layer, et la pagination pour cibler le résultat.
timeline overview fournit un contexte structuré compact sans octets d’image : IDs ordonnés, séquence par piste, intervalles timeline/source, plages de découpe visibles, coordonnées de frame, état audio/vidéo, effets, et écarts ou chevauchements voisins. Les intervalles et plages de frames sont exclusifs en fin ; les numéros de frame commencent à un. Les frames source utilisent le FPS source ; les coordonnées timeline et images clés utilisent le FPS projet. Utilisez --layer et --start/--end pour cibler, et --limit/--offset pour paginer (par défaut 100, maximum 500 éléments). Les clips remappés temporellement retiennent explicitement les correspondances source inférées. Utilisez la révision retournée avec edit apply --expect-revision.
Aperçus de frames et planches-contact
Rendez une seule frame avec thumbnail ou échantillonnez une plage avec strip. Utilisez file pour inspecter les médias source et timeline pour inspecter la vidéo composée, y compris les effets et clips en couches:
openshot-cli file thumbnail FILE_ID --frame 301 --output /tmp/source.png
openshot-cli file strip FILE_ID --start 10 --end 20 --count 12 --output /tmp/source-strip.png
openshot-cli timeline thumbnail --frame 91 --output /tmp/timeline-frame.png
openshot-cli timeline strip --start 0 --end 20 --count 12 --output /tmp/timeline-strip.png
Les images de frames sont par défaut en 320x180 pixels ; les planches-contact par défaut en 160x90 par vignette, plus les étiquettes de timecode. Utilisez --width et --height pour choisir la résolution de sortie. Les réponses incluent les métadonnées exactes d’échantillon/frame. Les planches-contact aident à revoir la composition sur une séquence ; utilisez les aperçus d’images clés et la vidéo rendue pour évaluer le mouvement entre ces échantillons.
Images de la timeline
Capturez la disposition des pistes de l’éditeur, y compris sa règle, ses vignettes, ses effets, ses transitions et ses formes d’onde :
openshot-cli timeline view --start 0 --end 20 --pixels-per-second 80 --output /tmp/tracks.png
Spécifier --output sélectionne le format d’image ; --format image le sélectionne également explicitement. La capture ne modifie pas la vue ni le projet de l’éditeur. Les réponses incluent les ID des clips et le timing ainsi que les limites en pixels.
Les images font par défaut 1280 pixels de large, avec une hauteur adaptée aux pistes utilisées. Utilisez --width, --height ou --all-tracks pour ajuster la disposition, et --track-size ou --track-label-width pour ajuster les pistes et les étiquettes. La plage de début/fin détermine le zoom ; --pixels-per-second dérive la largeur à partir de la plage temporelle.
Vues des formes d’onde audio
Choisissez --mode waveforms pour inspecter les enveloppes audio sur la timeline :
openshot-cli timeline view --start 5 --end 12 --mode waveforms --output /tmp/waves.png
--mode auto utilise l’affichage des formes d’onde mises en cache ; --mode thumbnails affiche plutôt des vignettes. Les formes d’onde représentent les niveaux crête/RMS de la source avec les ajustements de volume et de timing du clip, avant les effets audio ou le mixage.
L’extraction des formes d’onde non mises en cache décode les sources entières, limitée à 600 secondes par source et 1200 secondes-source par requête. Réduire la plage visible ne diminue pas ce travail de décodage. Pour les sources plus longues, générez d’abord les formes d’onde dans l’éditeur ou utilisez le mode vignette. Les requêtes suivantes peuvent réutiliser les formes d’onde mises en cache.
Sortie d’image et limites
Les chemins d’image doivent être de nouveaux fichiers PNG dans des répertoires existants. Les images sont limitées à 4096 pixels par axe, 8 388 608 pixels au total, et 64 échantillons de planche-contact. Les requêtes dépassant ces limites échouent avant le rendu.
Les images sont écrites dans des fichiers ; les réponses JSON incluent leurs chemins et les tailles image_bytes. L’inspection attend la fin de l’image, et les requêtes volumineuses peuvent occuper brièvement l’éditeur.
Gestion des délais d’attente des commandes
Un délai d’attente d’une requête ne signifie pas qu’une mutation a échoué. Utilisez l’ID de l’opération dans l’erreur avec operation get ID avant de réessayer. operation list découvre les mutations récentes ainsi que leurs états, révisions et résultats. Les opérations terminées conservent leurs résultats lorsqu’ils sont suffisamment petits, y compris les ID d’objets retournés. Le stockage est limité à 100 opérations et 4 Mio, avec les corps de résultats individuels omis au-delà de 256 Kio. Ces enregistrements ne durent que pendant la session en cours. Ils ne restaurent pas les projets après un plantage ni n’empêchent une commande répétée d’appliquer la même modification à nouveau. Les tâches d’export ont leurs propres commandes status/list.