---
title: CLI | RunAPI
description: Installez et utilisez chaque commande du CLI RunAPI pour les actions
  de modèle, les tâches, les fichiers, les téléversements, les informations de compte,
  la tarification, les rappels et Harness.
url: https://runapi.ai/fr/docs/resources/cli.md
canonical: https://runapi.ai/fr/docs/resources/cli
locale: fr
---

> Version HTML: https://runapi.ai/fr/docs/resources/cli
> Index du site pour les agents: https://runapi.ai/llms.txt

# CLI

La CLI RunAPI est un client terminal JSON-first pour les actions de modèle et les
outils de compte. Elle écrit les données de résultat sur la sortie standard et
la progression opérationnelle sur l'erreur standard, ce qui lui permet de fonctionner aussi
bien dans un terminal, dans des scripts shell, des tâches CI et Harness.

## Installer

Installez la version actuelle sur Linux ou macOS :

```shell
curl -fsSL https://runapi.ai/cli/install.sh | sh
```

Les installations via Homebrew et depuis les sources Go sont également disponibles :

```shell
brew install runapi-ai/tap/runapi
go install github.com/runapi-ai/cli/cmd/runapi@latest
```

Sous Windows, téléchargez l'archive `windows-amd64` ou `windows-arm64` correspondante
depuis la [dernière version CLI][1], extrayez `runapi.exe` et ajoutez-le
au `PATH`.



[1]: https://github.com/runapi-ai/cli/releases/latest

Épinglez l'installateur à une version ou à un répertoire d'installation lorsqu'un
déploiement nécessite un binaire reproductible :

```shell
curl -fsSL https://runapi.ai/cli/install.sh | sh -s -- --version v0.13.1
curl -fsSL https://runapi.ai/cli/install.sh | sh -s -- --dir "$HOME/.local/bin"
```

L'installateur accepte également `RUNAPI_VERSION`, `RUNAPI_INSTALL_DIR`,
`RUNAPI_INSTALL_BASE`, `RUNAPI_DOWNLOAD_BASE` et
`RUNAPI_SKIP_LIBC_CHECK=1`.

## Démarrage rapide

Sur un poste de travail, connectez-vous dans le navigateur et confirmez la source des identifiants :

```shell
runapi login
runapi auth status
```

Exécuter une action de modèle avec une entrée JSON en ligne ou un fichier JSON :

```shell
runapi nano-banana text-to-image --input '{"prompt":"a hummingbird drinking espresso","aspect_ratio":"1:1"}'
runapi nano-banana text-to-image --input-file request.json
```

La plupart des actions de modèle sont asynchrones. Elles attendent un résultat terminal par
défaut ; ajoutez `--async` pour retourner la tâche immédiatement et utilisez `wait`
plus tard :

```shell
TASK_ID=$(runapi suno text-to-music --async --input '{"model":"suno-v5","vocal_mode":"instrumental","style":"minimal piano","title":"Short Piano Theme"}' | jq -r '.id')
runapi wait "$TASK_ID" --service suno --action text-to-music
```

## Conventions des commandes

Chaque commande émet du JSON sur la sortie standard, sauf si une option demande
explicitement une valeur scalaire, comme `files create --url-only` ou `listen
--print-secret`. Les messages de progression et de diagnostic restent sur la sortie
d'erreur standard, de sorte que le JSON peut circuler en toute sécurité vers `jq` :

```shell
runapi nano-banana text-to-image --input-file request.json \
  | jq -r '.images[].url' \
  | xargs -I{} curl -OL {}
```

Les actions du modèle acceptent exactement une source d'entrée de requête :

* `--input '<json object>'` fournit du JSON inline.
* `--input-file path/to/request.json` charge du JSON depuis un fichier.
* `--input-file -` lit du JSON depuis l'entrée standard.

Utilisez `runapi <service> <action> --help` avant de construire une requête.
La CLI installée liste les champs actuels de l'action, les identifiants de modèle acceptés
et les contraintes de validation.

Ces options globales s'appliquent à chaque commande :

| Option | Rôle |
|----------
| `--api-key` | Utilise une clé API pour cette invocation. Remplace `RUNAPI_API_KEY`. |
| `--base-url` | Utilise une origine d'API différente pour cette invocation. |
| `--timeout` | Définit le délai d'expiration global de la commande et l'attente maximale d'une tâche. La valeur par défaut est 15 minutes. |
| `--poll-interval` | Définit l'intervalle d'interrogation des tâches. La valeur par défaut est 3 secondes. |
| `--async` | Retourne immédiatement après la soumission d'une action de modèle asynchrone. |
| `--quiet` | Supprime la progression sur la sortie d'erreur standard sans modifier la sortie JSON. |

## Actions du modèle

La forme de la commande de modèle est `runapi <service> <action>`. Les
actions synchrones retournent leur réponse immédiatement. Pour les actions asynchrones, le
comportement par défaut est de soumettre, d'interroger et de retourner le résultat terminal de la tâche ;
`--async` retourne la réponse de création à la place.

Pour les champs d'URL de média de niveau supérieur, un chemin de fichier local lisible est téléversé avant l'exécution de l'action du modèle. Les URL `http://` et `https://` existantes sont envoyées sans modification. Utilisez `files create` lorsque vous avez besoin d'une URL temporaire réutilisable, lorsque la source est une URL distante ou lorsque la source est une donnée Base64.

### Actions audio et musicales

* `suno` : `add-instrumental`, `add-vocals`, `blend-lyrics`,
  `boost-style`, `check-voice`, `convert-audio`, `cover-audio`,
  `create-mashup`, `extend-music`, `generate-artwork`,
  `generate-lyrics`, `generate-midi`, `generate-persona`,
  `generate-voice`, `get-timestamped-lyrics`,
  `regenerate-validation-phrase`, `replace-section`,
  `separate-audio-stems`, `text-to-music`, `text-to-sound`,
  `visualize-music`, `voice-to-validation-phrase`
* `producer` : `text-to-music`
* `gemini-omni` : `create-audio`, `create-character`, `text-to-video`
* `openai-tts` : `text-to-speech`
* `fish-audio` : `text-to-speech`
* `gemini-tts` : `text-to-speech`
* `elevenlabs` : `isolate-audio`, `speech-to-text`, `text-to-dialogue`,
  `text-to-sound`, `text-to-speech`

### Actions sur les images

* `nano-banana` : `edit-image`, `text-to-image`
* `imagen-4` : `remix-image`, `text-to-image`
* `seedream` : `decompose-layers`, `edit-image`, `text-to-image`
* `flux` : `remix-image`, `text-to-image`
* `flux-2` : `remix-image`, `text-to-image`
* `flux-kontext` : `text-to-image`
* `qwen-2` : `edit-image`, `text-to-image`
* `qwen-3` : `edit-image`, `text-to-image`
* `qwen-image` : `edit-image`, `remix-image`, `text-to-image`
* `recraft` : `remove-background`, `upscale-image`
* `z-image` : `text-to-image`
* `ideogram-v3` : `edit-image`, `reframe-image`, `remix-image`,
  `text-to-image`
* `gpt-image` : `edit-image`, `text-to-image`
* `gpt-image-2` : `edit-image`, `text-to-image`
* `gpt-4o-image` : `text-to-image`
* `midjourney` : `edit-image`, `get-seed`, `image-to-prompt`,
  `shorten-prompt`, `text-to-image`

### Actions vidéo et animation

* `veo-3-1` : `extend-video`, `text-to-video`, `upscale-video`
* `seedance` : `text-to-video`
* `runway` : `extend-video`, `text-to-video`
* `runway-aleph` : `edit-video`
* `kling` : `avatar`, `edit-video`, `extend-video`, `image-to-video`,
  `motion-control`, `text-to-video`
* `infinitetalk` : `audio-to-video`
* `omnihuman` : `audio-to-video`, `human-identification`,
  `subject-detection`
* `wan` : `animate`, `edit-video`, `image-to-video`, `speech-to-video`,
  `text-to-image`, `text-to-video`
* `luma` : `modify-video`
* `hailuo` : `image-to-video`, `text-to-video`
* `volcengine-lip-sync` : `lip-sync-video`
* `happyhorse` : `edit-video`, `image-to-video`, `text-to-video`
* `grok-imagine` : `edit-image`, `extend`, `image-to-video`,
  `text-to-image`, `text-to-video`, `upscale-image`
* `topaz` : `upscale-image`, `upscale-video`
* `midjourney` : `extend-video`, `image-to-video`

La liste ci-dessus constitue l'inventaire complet des actions de cette version de la CLI.
Le contrat exact de requête et de réponse de chaque action est disponible dans la
[Référence API](https://runapi.ai/fr/docs/api/openai/chat-completions.md), et l'aide de la commande locale
est la source des champs propres à chaque version.

## Cycle de vie de la tâche

Utilisez `get` pour inspecter l'état actuel d'une Task asynchrone sans
attendre. Utilisez `wait` pour interroger jusqu'à ce qu'elle se termine, échoue ou atteigne le
délai d'expiration de la commande. Les deux commandes nécessitent le service et l'action d'origine
afin que la CLI puisse sélectionner la forme de résultat de Task correcte.

```shell
runapi get "$TASK_ID" --service suno --action text-to-music
runapi wait "$TASK_ID" --service suno --action text-to-music --poll-interval 5s
```

## Fichiers

`runapi files create` conserve le flux d'URL d'importation de fichier temporaire. Il importe un chemin local, une URL distante ou une source Base64 et retourne une URL qui expire après une heure.

```shell
runapi files create ./reference.png --url-only
runapi files create --url https://example.test/reference.png --file-name reference.png
runapi files create --base64 "$(base64 < reference.png)" --file-name reference.png
```

Les sources sont mutuellement exclusives. `--url-only` affiche uniquement l'URL ;
omettez cette option pour recevoir la réponse JSON complète.

Utilisez le cycle de vie de fichier persistant lorsque vous avez besoin d'un `file_id`
stable plutôt que d'une URL :

```shell
runapi files create-file ./knowledge.pdf
runapi files list --order desc
runapi files retrieve file_123
runapi files content file_123 --output ./knowledge-copy.pdf
runapi files delete file_123
```

`content` requiert `--output` ; passez `-` pour écrire les octets exacts du fichier sur la sortie standard. Consultez [Files and Uploads](https://runapi.ai/fr/docs/resources/files.md) pour connaître les limites, l'isolation de compte et le cycle de vie REST.

## Téléversements

Utilisez les Uploads pour envoyer une ou plusieurs Parts avant de composer le File final.
Create déclare le nombre d'octets final et les métadonnées ; répétez `--part-id` dans
l'ordre de composition lors de la finalisation :

```shell
runapi uploads create --bytes 1048576 --filename archive.bin --mime-type application/octet-stream
runapi uploads add-part upload_123 ./archive.part-01
runapi uploads complete upload_123 --part-id part_123
runapi uploads cancel upload_123
```

## Compte et tarification

Inspectez l'utilisateur authentifié et le compte sélectionné, puis interrogez le solde et les compteurs de dépenses :

```shell
runapi account info
runapi account balance
```

`pricing list` lit les grilles tarifaires en vigueur. Filtrez par service, action ou modèle. `pricing quote` estime la réservation de tâche pour un service et une action requis ; ajoutez `--model` lorsque l'action est spécifique à un modèle et fournissez les paramètres de tarification avec `--params` ou `--params-file`.

```shell
runapi pricing list --service suno --action text-to-music --model suno-v4
runapi pricing quote --service suno --action text-to-music --model suno-v4 \
  --params '{"vocal_mode":"auto_lyrics","prompt":"A chill lo-fi beat"}'
runapi pricing quote --service suno --action text-to-music --params-file pricing-inputs.json
```

Les commandes de tarification ne nécessitent pas d'identifiants, sauf si le devis fait référence
à une tâche source appartenant à un compte.

## Authentification et configuration

`runapi login` ouvre un flux d'autorisation dans le navigateur et enregistre les identifiants résultants. Pour les serveurs et les environnements CI, `auth import-token` accepte une clé API depuis l'entrée standard, la vérifie par défaut et l'enregistre sans exposer la valeur dans la liste des processus ou l'historique du shell :

```shell
printf '%s' "$RUNAPI_API_KEY" | runapi auth import-token --token -
runapi auth status
runapi logout
```

`auth import-token --skip-verify` prend en charge la configuration hors ligne d'image. Utilisez-le uniquement lorsque la vérification ne peut pas s'exécuter pendant la configuration ; `auth status` vérifie les identifiants actifs ultérieurement.

La priorité de la clé API est `--api-key`, puis `RUNAPI_API_KEY`, puis le fichier
de configuration CLI local. La priorité de la Base URL est `--base-url`, puis
`RUNAPI_BASE_URL`, puis la Base URL enregistrée, puis `https://runapi.ai`.
Le fichier de configuration est `~/.config/runapi/config.json`, ou
`$XDG_CONFIG_HOME/runapi/config.json` lorsque `XDG_CONFIG_HOME` est défini.

## Écouteur de rappel local

`runapi listen` reçoit les rappels de tâche pour une clé API sélectionnée et transfère éventuellement chaque rappel signé vers un point de terminaison HTTP local. Une connexion par navigateur est requise avant d'utiliser les opérations d'écoute.

```shell
runapi login
runapi api-keys list --json
runapi listen http://localhost:3000/webhooks/runapi --callback-api-key-id token_abc123
```

L'URL positionnelle et `--forward-to` sont des alternatives. L'écouteur
écrit chaque corps de callback signé sur la sortie standard. Une tâche avec
`callback_url` continue de livrer à cette URL et est également copiée vers
l'écouteur local.

Après réception d'un événement d'écoute valide, le CLI l'acquitte avant
d'effectuer la requête HTTP locale. Chaque événement est transmis localement une seule fois :
les réponses non-2xx et les erreurs de connexion sont signalées dans le terminal,
mais elles ne déclenchent pas de relecture de l'événement par l'écouteur. Ce comportement de débogage local
ne modifie pas les nouvelles tentatives de livraison pour le `callback_url` d'une tâche.

Chaque compte peut exécuter jusqu'à 100 écouteurs actifs par clé d'abonnement
aux rappels et 1 000 écouteurs actifs au total. Lorsqu'une limite est
atteinte, arrêtez un écouteur inactif ou attendez et réessayez. La réponse de l'API
indique si la clé sélectionnée, votre compte ou la capacité globale
du service est saturée.

Un écouteur inactif vérifie la présence de nouveaux événements toutes les 15 à 30 secondes environ.
Les événements sont généralement trouvés en moins de 15 secondes et sont lus
immédiatement lorsqu'ils sont disponibles. Si une limite est atteinte, arrêtez un écouteur inactif
ou patientez et réessayez. Le comportement de livraison et d'acquittement existant reste inchangé.

La sélection de la clé s'effectue dans l'ordre suivant : `--callback-api-key-id` pour une seule commande, `callback_api_key_id` dans le fichier `.runapi.toml` du projet, puis un sélecteur interactif. La configuration du projet est enregistrée à la racine Git, ou dans le répertoire courant en dehors d'un dépôt Git, et ne contient que l'identifiant stable :

```toml
callback_api_key_id = "token_abc123"
```

Affichez le secret de signature d'écoute d'une clé sélectionnée sans démarrer de
listener, ou faites-le pivoter après exposition :

```shell
runapi listen --print-secret --callback-api-key-id token_abc123
runapi listen --rotate-secret --callback-api-key-id token_abc123
```

La rotation invalide les écouteurs actifs pour la clé sélectionnée. Mettez à jour
chaque vérificateur local avec le nouveau secret affiché avant de redémarrer son
écouteur.

## Harnais

Installez la compétence CLI RunAPI portable dans un Harness pris en charge, inspectez les cibles prises en charge ou supprimez une compétence installée :

```shell
runapi agent install-skill --target codex
runapi agent list-targets
runapi agent uninstall-skill --target codex
```

Les cibles intégrées sont `claude`, `codex`, `gemini`, `openclaw` et
`hermes`. `install-skill` accepte `--version` pour épingler une version de skill,
`--target-dir` pour une destination personnalisée, `--source` pour un dépôt source,
et `--force` pour écraser un répertoire de skill existant.

## Complétion shell et version

Générez des scripts de complétion pour Bash, Zsh, Fish ou PowerShell. Par exemple, chargez la complétion Bash dans le shell courant :

```shell
source <(runapi completion bash)
runapi completion zsh
runapi completion fish
runapi completion powershell
runapi version
```

Utilisez `runapi --help` pour lister les commandes, `runapi <command> --help` pour les
options d'une commande, et `runapi <service> <action> --help` pour les champs
d'une action de modèle.

## Codes de sortie

Les commandes se terminent avec un code non nul que les scripts peuvent gérer :

| Code | Signification |
|----------
| `0` | Succès |
| `2` | Échec d'authentification ou plateforme non prise en charge |
| `3` | Crédits insuffisants ou dépendance locale requise manquante |
| `4` | Erreur de validation, ressource introuvable ou erreur d'analyse du manifeste |
| `5` | Délai dépassé, échec du téléchargement ou non-concordance de la somme de contrôle |
| `6` | Limite de débit atteinte |
| `7` | Échec de la tâche |

Pour les champs de requête, les valeurs de statut de tâche, les charges utiles de rappel, les corps d'erreur et la gestion des limites de débit, continuez avec la [référence API
](https://runapi.ai/fr/docs/api/openai/chat-completions.md). Utilisez les [SDK](https://runapi.ai/fr/docs/resources/sdks.md) lorsque le même flux de travail appartient à une application.

---

## Plus de ressources de RunAPI

- [Accueil](https://runapi.ai/fr/.md)
- [Catalogue de modèles](https://runapi.ai/fr/models.md)
- [Tarifs](https://runapi.ai/fr/pricing.md)
- [Fournisseurs](https://runapi.ai/fr/models)
- [Documentation](https://runapi.ai/fr/docs/guides)
- [SDK](https://runapi.ai/fr/sdk.md)
- [CLI](https://runapi.ai/fr/cli.md)
- [Serveur MCP](https://runapi.ai/fr/mcp.md)
- [Claude Code vs Cursor](https://runapi.ai/fr/claude-code-vs-cursor.md)
- [Configuration de l’API Cursor](https://runapi.ai/fr/cursor-api-setup.md)
- [RunAPI vs OpenRouter](https://runapi.ai/fr/openrouter-alternative.md)
- [Entreprise](https://runapi.ai/fr/contact.md)
- [Contact](https://runapi.ai/fr/contact.md)
- [Conditions](https://runapi.ai/fr/terms.md)
- [Confidentialité](https://runapi.ai/fr/privacy.md)
- [Index du site pour les agents](https://runapi.ai/llms.txt)

Contact: contact@runapi.ai

## Données structurées

```json
[
  {
    "@context": "https://schema.org",
    "inLanguage": "fr",
    "@type": "WebSite",
    "name": "RunAPI",
    "url": "https://runapi.ai/fr",
    "potentialAction": {
      "@type": "SearchAction",
      "target": {
        "@type": "EntryPoint",
        "urlTemplate": "https://runapi.ai/fr/models?q={search_term_string}"
      },
      "query-input": "required name=search_term_string"
    }
  },
  {
    "@context": "https://schema.org",
    "inLanguage": "fr",
    "@type": "Organization",
    "name": "RunAPI",
    "url": "https://runapi.ai/fr",
    "logo": {
      "@type": "ImageObject",
      "url": "https://runapi.ai/fricon.svg"
    },
    "sameAs": [
      "https://github.com/runapi-ai"
    ]
  },
  {
    "@context": "https://schema.org",
    "inLanguage": "fr",
    "@type": "TechArticle",
    "headline": "CLI",
    "description": "Installez et utilisez chaque commande du CLI RunAPI pour les actions de modèle, les tâches, les fichiers, les téléversements, les informations de compte, la tarification, les rappels et Harness.",
    "url": "https://runapi.ai/fr/docs/resources/cli",
    "mainEntityOfPage": "https://runapi.ai/fr/docs/resources/cli"
  }
]
```