Aller à la documentation
Desktop 1.0.81Documentation publique · Lecture sans compte

Vos workflows.Avec MetaGhost.

Connectez vos scripts et n8n à MetaGhost ouvert sur votre ordinateur. Envoyez des images ou des vidéos, suivez chaque tâche et récupérez son résultat.

Pour la version publiée Desktop 1.0.81

Ce guide et tous les téléchargements correspondent au Desktop 1.0.81. Utilisez les routes /api indiquées ici. La réponse de santé identifie le logiciel avec version: "1.0.81". La documentation sera mise à jour lors de la prochaine release Desktop.

De la connexion au premier résultat

  1. Ouvrez MetaGhost Desktop, connectez-vous et allez dans Settings → API.
  2. Activez le serveur API, gardez l’accès distant désactivé, générez votre clé si nécessaire puis cliquez sur Apply changes. Laissez Desktop ouvert.
  3. Vérifiez la version dans un terminal sur le même ordinateur. Cette requête ne nécessite pas de clé.
PowerShell / Windows
curl.exe "http://127.0.0.1:3847/api/health"
JSON
{
  "status": "ok",
  "version": "1.0.81",
  "activeJobs": 0
}

Téléchargez l’un des exemples complets. Ils créent une tâche locale, attendent sa fin, détectent les résultats partiels et téléchargent le premier résultat. Python nécessite la version 3.10+, JavaScript Node.js 22+. Aucun paquet supplémentaire.

PowerShell
$env:METAGHOST_API_KEY = Read-Host "MetaGhost API key"
# Replace the paths with your own files and folders.
python .\quickstart.py "C:\Media\photo.jpg" "C:\Media\output" ".\result.jpg"
# Or, with Node.js:
node .\quickstart.mjs "C:\Media\photo.jpg" "C:\Media\output" ".\result-2.jpg"

Utilisez une petite image de test vous appartenant et un nouveau dossier de sortie. Adaptez les extensions pour une vidéo. La clé API est lue depuis votre environnement et n’est pas incluse dans les exemples. Le fichier à télécharger ne doit pas déjà exister. L’attente est limitée à 10 minutes ; arrêter le script n’annule pas la tâche Desktop.

Connexion et accès

L’API fonctionne dans votre logiciel Desktop à l’adresse http://127.0.0.1:3847/api par défaut. Gardez MetaGhost ouvert et utilisez le port affiché dans Settings → API. Ce guide public ne nécessite pas de connexion ; le traitement utilise votre logiciel Desktop et ses presets configurés.

HTTP
GET http://127.0.0.1:3847/api/presets
Authorization: Bearer YOUR_LOCAL_API_KEY

Toutes les routes sauf GET /api/health nécessitent la clé Bearer de Settings → API. Une clé absente ou invalide renvoie 401. Utilisez la clé API, pas le mot de passe du compte. Après génération d’une nouvelle clé et application des réglages, mettez à jour les scripts et les identifiants n8n. Gardez la clé hors des URL et des workflows exportés.

Fichiers et presets

Fournissez un chemin absolu filePath pour une entrée, ou files pour plusieurs entrées. Les chemins concernent l’ordinateur Desktop et les fichiers doivent déjà exister. Utilisez un outputFolder absolu ; Desktop le crée si nécessaire. Un chemin sur une autre machine ou dans un conteneur n’est pas automatiquement accessible.

Images acceptées : JPG, JPEG, PNG, WebP, HEIC, BMP, TIFF. Vidéos acceptées : MP4, MOV, AVI, MKV, WebM, M4V. Les autres extensions sont rejetées.

Téléverser un fichier si nécessaire

POST /api/upload accepte les octets du fichier et nécessite X-Filename. Il renvoie filePath, originalName et size ; transmettez ce filePath à POST /api/jobs. Maximum : 500 Mio par fichier. Utilisez des octets bruts, pas multipart/form-data. Un téléversement trop volumineux peut fermer la connexion avant la réponse d’erreur.

PowerShell · raw bytes
curl.exe "http://127.0.0.1:3847/api/upload" `
  -H "Authorization: Bearer $env:METAGHOST_API_KEY" `
  -H "Content-Type: application/octet-stream" `
  -H "X-Filename: photo.jpg" `
  --data-binary "@C:\Media\photo.jpg"

Utiliser un preset enregistré

GET /api/presets renvoie les tableaux image et video des noms de presets enregistrés. Donnez à preset le nom exact enregistré dans Desktop. Pour un lot mixte image/vidéo, ce nom doit exister dans les deux listes. Omettez preset pour les paramètres de base. Configurez les options de traitement dans le preset Desktop ; la requête API sélectionne son nom.

JSON
{
  "filePath": "C:\\Media\\photo.jpg",
  "outputFolder": "C:\\Media\\output",
  "batchCount": 1,
  "preset": "My saved image preset"
}

Google Drive

Connectez Google Drive dans les réglages Desktop, puis vérifiez GET /api/drive/status. clientConfigured et connected doivent être true. Utilisez driveInputFolder à la place de filePath/files et/ou driveOutputFolder à la place de outputFolder. Ce sont des identifiants de dossiers accessibles au compte connecté, pas des liens de partage. Une connexion manquante renvoie 412.

JSON
{
  "driveInputFolder": "YOUR_INPUT_FOLDER_ID",
  "driveOutputFolder": "YOUR_OUTPUT_FOLDER_ID",
  "batchCount": 1
}

Les transferts Drive utilisent le réseau. Pour une sortie Drive, le traitement peut atteindre completed avant la fin du téléversement. Continuez à interroger la tâche jusqu’à la présence de drive.uploadResult ou drive.uploadError, puis examinez uploadResult.errors / uploadResult.cancelled. Récupérez les fichiers livrés sur Drive : les sorties locales temporaires peuvent déjà être supprimées et /api/download peut renvoyer 404.

Envoyer, suivre, récupérer

POST /api/jobs202 + jobIdGET /api/jobs/{jobId}GET /api/download/{jobId}
JSON
{
  "filePath": "C:\\Media\\photo.jpg",
  "outputFolder": "C:\\Media\\output",
  "batchCount": 1
}

POST renvoie 202 avec jobId, status, inputFiles, batchCount, totalOperations, skipped, position et drive. 202 signifie acceptée. Examinez skipped immédiatement. Avec une entrée Drive, inputFiles et totalOperations sont initialement null car les fichiers sont découverts ensuite.

Interrogez GET /api/jobs/{jobId} toutes les deux secondes. queued et processing sont en cours ; completed, failed et cancelled terminent le traitement. Une tâche simple expose result.outputPath ou error. Un lot expose results et errors. Un lot completed peut contenir des échecs : vérifiez errors et le nombre de résultats réussis. La 1.0.81 ne fournit pas de champ outcome.

Téléchargez une sortie locale avec GET /api/download/{jobId}?index=0. Pour un lot, index sélectionne une entrée de results à partir de zéro ; il ne correspond pas à l’index des fichiers d’entrée. Un téléchargement avant la fin renvoie 400. Une tâche, un index ou un fichier absent renvoie 404.

Ne relancez pas automatiquement la création

Le Desktop 1.0.81 ne prend pas en charge Idempotency-Key : chaque POST /api/jobs peut créer une autre tâche. Après un délai dépassé ou une réponse perdue, examinez GET /api/jobs avant de recommencer. Les exemples envoient une seule création et conservent le jobId reçu. Arrêter leur attente n’annule pas la tâche Desktop.

Annulation et historique

DELETE /api/jobs/{jobId} demande l’annulation d’une tâche en attente ou en cours. Relisez son statut : le fichier du lot en cours peut terminer et les fichiers déjà créés peuvent rester. GET /api/jobs liste jusqu’à 50 tâches récentes. Les tâches terminées deviennent éligibles au nettoyage après une heure, avec un passage toutes les dix minutes. Un redémarrage Desktop perd cet historique en mémoire. DELETE /api/jobs efface les entrées terminées.

Ce que permet l’API de la 1.0.81

Cette release expose le spoofing d’images et de vidéos par preset, les téléversements, les téléchargements locaux, la gestion des tâches et l’état de connexion Drive. Les autres outils visibles dans Desktop ne disposent pas automatiquement d’une route API. Utilisez uniquement les routes et les champs de la référence ci-dessous.

  • Une tâche est traitée à la fois, avec jusqu’à 10 tâches en attente ; une file pleine renvoie 429.
  • Gardez les requêtes JSON sous 64 Kio et les fichiers téléversés à 500 Mio maximum.
  • batchCount répète chaque fichier valide. Commencez par l’entier positif 1 et de petits lots, puis augmentez progressivement selon la capacité de votre ordinateur.
  • Cette release ne propose pas de route API pour le solde de crédits ou une estimation de coût. Choisissez et vérifiez le preset de traitement dans Desktop avant l’automatisation.

Un workflow n8n prêt à configurer

Commencez avec n8n installé directement sur le même ordinateur que Desktop. Le workflow vérifie le Desktop 1.0.81, crée une tâche locale standard, attend au maximum 10 minutes, gère les échecs et résultats partiels puis récupère le premier résultat comme donnée binaire. Il reste inactif jusqu’à une exécution manuelle.

Télécharger le workflow n8n
  1. Importez le fichier JSON dans n8n. Ouvrez Configure et remplacez filePath et outputFolder par des chemins de l’ordinateur Desktop.
  2. Créez un identifiant Header Auth : Name = Authorization, Value = Bearer suivi d’un espace et de votre clé API Desktop. Sélectionnez-le dans Submit job, Read job et Download output. Le workflow exporté ne contient aucune clé.
  3. Lancez le déclencheur manuel. Download output expose le champ binaire data ; ajoutez votre nœud de stockage pour sauvegarder ou transférer le résultat. Commencez avec un petit fichier de test.

Docker ou n8n Cloud ?

127.0.0.1 désigne la machine ou le conteneur n8n, pas forcément votre PC. Un conteneur Docker nécessite une adresse hôte accessible et une connexion privée configurée volontairement. n8n Cloud ne peut pas accéder au localhost de votre PC. Pour ce workflow, utilisez n8n auto-hébergé sur l’ordinateur Desktop. N’exposez jamais le port 3847 directement à Internet ; un accès distant nécessite un réseau privé authentifié et des restrictions sur l’hôte.

Configuration des identifiants n8n · HTTP Request

Référence API

OpenAPI est un fichier qui décrit l’API : routes, authentification, paramètres et réponses. Les outils de développement peuvent l’importer pour préparer des requêtes ou générer du code d’intégration. La lecture du guide suffit pour commencer ; ce téléchargement est facultatif. 3.1 désigne la version du format OpenAPI, ce guide décrit l’API livrée avec le Desktop 1.0.81.

Tous les chemins ci-dessous sont relatifs à http://127.0.0.1:3847/api. Dépliez une route pour son contrat de requête et de réponse. Les schémas conservent les noms de champs anglais de l’API. Cette page est uniquement documentaire et n’appelle jamais votre Desktop depuis le navigateur.

GET/health

Check Desktop 1.0.81 and active jobs

Sans authentification

JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Health"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
GET/presets

List saved image and video preset names

Authorization: Bearer YOUR_LOCAL_API_KEY

JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Presets"
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
GET/drive/status

Check the Desktop Google Drive connection

Authorization: Bearer YOUR_LOCAL_API_KEY

JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/DriveStatus"
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
POST/upload

Upload raw image or video bytes

Authorization: Bearer YOUR_LOCAL_API_KEY

Raw bytes, not multipart. Maximum 500 MiB (524288000 bytes). Oversized uploads and write errors may close the connection before a JSON error arrives. There is no upload-retention guarantee in 1.0.81.

JSON
{
  "parameters": [
    {
      "name": "X-Filename",
      "in": "header",
      "required": true,
      "schema": {
        "type": "string",
        "description": "Name ending in .jpg, .jpeg, .png, .webp, .heic, .bmp, .tiff, .mp4, .mov, .avi, .mkv, .webm or .m4v."
      }
    }
  ]
}
JSON
{
  "requestBody": {
    "required": true,
    "content": {
      "application/octet-stream": {
        "schema": {
          "type": "string",
          "format": "binary"
        }
      }
    }
  }
}
JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Upload"
          }
        }
      }
    },
    "400": {
      "description": "Invalid request or incompatible job state",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "500": {
      "description": "Internal server or upload write error",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
POST/jobs

Create an image/video spoofing job

Authorization: Bearer YOUR_LOCAL_API_KEY

Each POST creates a new job. No automatic retries or Idempotency-Key support. JSON body ceiling: 64 KiB; exceeding it may close the connection. Local inputs are checked before acceptance; Drive inputs are discovered afterwards.

JSON
{
  "requestBody": {
    "required": true,
    "content": {
      "application/json": {
        "schema": {
          "$ref": "#/components/schemas/SpoofJobRequest"
        },
        "example": {
          "filePath": "C:\\Media\\photo.jpg",
          "outputFolder": "C:\\Media\\output",
          "batchCount": 1
        }
      }
    }
  }
}
JSON
{
  "responses": {
    "202": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/AcceptedJob"
          }
        }
      }
    },
    "400": {
      "description": "Invalid request or incompatible job state",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "412": {
      "description": "Google Drive is not configured or connected",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "429": {
      "description": "Ten jobs already waiting in the queue",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "500": {
      "description": "Internal server or upload write error",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
GET/jobs

List the 50 most recent jobs and queue state

Authorization: Bearer YOUR_LOCAL_API_KEY

In-memory history. Completed, failed and cancelled jobs become eligible for cleanup after one hour from completedAt, or createdAt when completedAt is absent. Cleanup runs every ten minutes. Restarting Desktop loses this history.

JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/JobList"
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
DELETE/jobs

Clear finished jobs from in-memory history

Authorization: Bearer YOUR_LOCAL_API_KEY

Efface l’historique terminé. Cette opération modifie les données.

JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "type": "object",
            "properties": {
              "cleared": {
                "type": "integer"
              }
            },
            "required": [
              "cleared"
            ]
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
GET/jobs/{jobId}

Read one job's progress and results

Authorization: Bearer YOUR_LOCAL_API_KEY

JSON
{
  "parameters": [
    {
      "name": "jobId",
      "in": "path",
      "required": true,
      "schema": {
        "type": "string",
        "pattern": "^[a-zA-Z0-9_-]+$"
      }
    }
  ]
}
JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Job"
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "404": {
      "description": "Unknown job, missing output or unsupported route",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
DELETE/jobs/{jobId}

Request cancellation of a queued or processing job

Authorization: Bearer YOUR_LOCAL_API_KEY

Inspect status again after cancellation. Already-produced files may remain. The currently processing batch file may finish before the queue stops.

Annule la tâche sélectionnée.

JSON
{
  "parameters": [
    {
      "name": "jobId",
      "in": "path",
      "required": true,
      "schema": {
        "type": "string",
        "pattern": "^[a-zA-Z0-9_-]+$"
      }
    }
  ]
}
JSON
{
  "responses": {
    "200": {
      "description": "Successful response",
      "content": {
        "application/json": {
          "schema": {
            "type": "object",
            "properties": {
              "jobId": {
                "type": "string"
              },
              "status": {
                "const": "cancelled"
              }
            },
            "required": [
              "jobId",
              "status"
            ]
          }
        }
      }
    },
    "400": {
      "description": "Invalid request or incompatible job state",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "401": {
      "description": "Invalid or missing API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "404": {
      "description": "Unknown job, missing output or unsupported route",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
GET/download/{jobId}

Download an existing local output of a completed job

Authorization: Bearer YOUR_LOCAL_API_KEY

For batches, index addresses the successful results array, not the original input array. A Drive-delivered temporary output may already have been cleaned up and return 404. An unfinished job returns 400.

JSON
{
  "parameters": [
    {
      "name": "jobId",
      "in": "path",
      "required": true,
      "schema": {
        "type": "string",
        "pattern": "^[a-zA-Z0-9_-]+$"
      }
    },
    {
      "name": "index",
      "in": "query",
      "schema": {
        "type": "integer",
        "minimum": 0,
        "default": 0
      }
    }
  ]
}
JSON
{
  "responses": {
    "200": {
      "description": "Output bytes; Content-Type follows the file extension and Content-Disposition contains the filename.",
      "content": {
        "application/octet-stream": {
          "schema": {
            "type": "string",
            "format": "binary"
          }
        }
      }
    },
    "400": {
      "description": "Job is not completed",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "401": {
      "description": "Invalid API key",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    },
    "404": {
      "description": "Unknown job, index or output file",
      "content": {
        "application/json": {
          "schema": {
            "$ref": "#/components/schemas/Error"
          }
        }
      }
    }
  }
}
Consulter les schémas référencés
Tous les schémas et paramètres réutilisables
#/components/securitySchemes
LocalApiKey
JSON
{
  "type": "http",
  "scheme": "bearer",
  "description": "Key generated in Desktop Settings > API."
}
#/components/schemas
Error
JSON
{
  "type": "object",
  "properties": {
    "error": {
      "type": "string"
    },
    "skipped": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/FileError"
      }
    }
  },
  "required": [
    "error"
  ]
}
FileError
JSON
{
  "type": "object",
  "properties": {
    "file": {
      "type": "string"
    },
    "error": {
      "type": "string"
    }
  },
  "required": [
    "file",
    "error"
  ]
}
Health
JSON
{
  "type": "object",
  "properties": {
    "status": {
      "const": "ok"
    },
    "version": {
      "const": "1.0.81"
    },
    "activeJobs": {
      "type": "integer",
      "minimum": 0
    }
  },
  "required": [
    "status",
    "version",
    "activeJobs"
  ]
}
Presets
JSON
{
  "type": "object",
  "properties": {
    "image": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "video": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "image",
    "video"
  ]
}
DriveStatus
JSON
{
  "type": "object",
  "properties": {
    "clientConfigured": {
      "type": "boolean"
    },
    "connected": {
      "type": "boolean"
    },
    "email": {
      "type": [
        "string",
        "null"
      ]
    },
    "scope": {
      "type": [
        "string",
        "null"
      ]
    }
  },
  "required": [
    "clientConfigured",
    "connected",
    "email",
    "scope"
  ]
}
DriveUploadResult
JSON
{
  "type": "object",
  "properties": {
    "uploaded": {
      "type": "integer",
      "minimum": 0
    },
    "errors": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "error": {
            "type": "string"
          }
        },
        "required": [
          "name",
          "error"
        ]
      }
    },
    "cancelled": {
      "type": "boolean"
    }
  },
  "required": [
    "uploaded",
    "errors"
  ]
}
Upload
JSON
{
  "type": "object",
  "properties": {
    "filePath": {
      "type": "string",
      "description": "Absolute path on the Desktop computer."
    },
    "originalName": {
      "type": "string"
    },
    "size": {
      "type": "integer",
      "minimum": 1
    }
  },
  "required": [
    "filePath",
    "originalName",
    "size"
  ]
}
SpoofJobRequest
JSON
{
  "type": "object",
  "properties": {
    "filePath": {
      "type": "string",
      "description": "Absolute path to one existing image or video."
    },
    "files": {
      "type": "array",
      "items": {
        "type": "string",
        "description": "Absolute path to an existing image or video."
      }
    },
    "driveInputFolder": {
      "type": "string",
      "description": "Folder ID accessible to the connected Desktop Drive account."
    },
    "outputFolder": {
      "type": "string",
      "description": "Absolute local output directory; created when missing."
    },
    "driveOutputFolder": {
      "type": "string",
      "description": "Destination folder ID accessible to the Desktop Drive account."
    },
    "preset": {
      "type": "string",
      "description": "Exact saved preset name for each input media type. Omit for basic defaults."
    },
    "batchCount": {
      "type": "integer",
      "minimum": 1,
      "default": 1,
      "description": "Variations per valid input. Send a positive integer and keep batches small; increase gradually according to your computer's capacity."
    }
  },
  "description": "Preset-driven image/video spoofing only. Choose filePath, files OR driveInputFolder, and outputFolder OR driveOutputFolder. No operation selector or idempotency support. Unknown extra fields are ignored by 1.0.81, not a way to enable another tool.",
  "allOf": [
    {
      "oneOf": [
        {
          "anyOf": [
            {
              "required": [
                "filePath"
              ]
            },
            {
              "required": [
                "files"
              ]
            }
          ]
        },
        {
          "required": [
            "driveInputFolder"
          ]
        }
      ]
    },
    {
      "oneOf": [
        {
          "required": [
            "outputFolder"
          ]
        },
        {
          "required": [
            "driveOutputFolder"
          ]
        }
      ]
    }
  ]
}
AcceptedJob
JSON
{
  "type": "object",
  "properties": {
    "jobId": {
      "type": "string"
    },
    "status": {
      "const": "queued"
    },
    "inputFiles": {
      "type": [
        "integer",
        "null"
      ]
    },
    "batchCount": {
      "type": "integer"
    },
    "totalOperations": {
      "type": [
        "integer",
        "null"
      ]
    },
    "skipped": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/FileError"
      }
    },
    "position": {
      "type": "integer",
      "description": "May be zero when processing has already started."
    },
    "drive": {
      "anyOf": [
        {
          "type": "null"
        },
        {
          "type": "object",
          "properties": {
            "input": {
              "type": "boolean"
            },
            "output": {
              "type": "boolean"
            }
          }
        }
      ]
    }
  },
  "required": [
    "jobId",
    "status",
    "inputFiles",
    "batchCount",
    "totalOperations",
    "skipped",
    "position",
    "drive"
  ]
}
Output
JSON
{
  "type": "object",
  "properties": {
    "outputPath": {
      "type": "string"
    }
  },
  "required": [
    "outputPath"
  ]
}
BatchOutput
JSON
{
  "type": "object",
  "properties": {
    "file": {
      "type": "string"
    },
    "outputPath": {
      "type": "string"
    }
  },
  "required": [
    "file",
    "outputPath"
  ]
}
Progress
JSON
{
  "type": "object",
  "properties": {
    "phase": {
      "type": "string"
    },
    "phaseProgress": {
      "type": "number"
    },
    "totalProgress": {
      "type": "number"
    },
    "currentFile": {
      "type": "integer"
    },
    "totalFiles": {
      "type": [
        "integer",
        "null"
      ]
    },
    "completedFiles": {
      "type": "integer"
    },
    "fileName": {
      "type": "string"
    }
  }
}
Job
JSON
{
  "type": "object",
  "properties": {
    "jobId": {
      "type": "string"
    },
    "status": {
      "type": "string",
      "enum": [
        "queued",
        "processing",
        "completed",
        "failed",
        "cancelled"
      ]
    },
    "type": {
      "type": "string",
      "enum": [
        "single",
        "batch"
      ]
    },
    "preset": {
      "type": "string"
    },
    "progress": {
      "$ref": "#/components/schemas/Progress"
    },
    "createdAt": {
      "type": "string"
    },
    "startedAt": {
      "type": [
        "string",
        "null"
      ]
    },
    "completedAt": {
      "type": [
        "string",
        "null"
      ]
    },
    "fileType": {
      "type": "string"
    },
    "fileName": {
      "type": "string"
    },
    "totalFiles": {
      "type": "integer"
    },
    "result": {
      "$ref": "#/components/schemas/Output"
    },
    "results": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/BatchOutput"
      }
    },
    "error": {
      "type": "string",
      "description": "Single-job failure."
    },
    "errors": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/FileError"
      }
    },
    "drive": {
      "type": "object",
      "properties": {
        "inputFolderId": {
          "type": [
            "string",
            "null"
          ]
        },
        "outputFolderId": {
          "type": [
            "string",
            "null"
          ]
        },
        "uploadResult": {
          "anyOf": [
            {
              "type": "null"
            },
            {
              "$ref": "#/components/schemas/DriveUploadResult"
            }
          ]
        },
        "uploadError": {
          "type": [
            "string",
            "null"
          ]
        }
      }
    }
  },
  "required": [
    "jobId",
    "status",
    "type",
    "preset",
    "progress",
    "createdAt",
    "startedAt",
    "completedAt"
  ],
  "description": "A completed batch may include errors or have no successful results. Check errors and results, plus skipped from POST. For Drive output, processing can reach completed before upload finishes; keep polling until uploadResult or uploadError is present, and inspect uploadResult.errors and uploadResult.cancelled. No outcome field exists in this release."
}
JobList
JSON
{
  "type": "object",
  "properties": {
    "jobs": {
      "type": "array",
      "items": {
        "$ref": "#/components/schemas/Job"
      }
    },
    "queueLength": {
      "type": "integer"
    },
    "processing": {
      "type": "boolean"
    }
  },
  "required": [
    "jobs",
    "queueLength",
    "processing"
  ]
}

Si quelque chose ne fonctionne pas

Connection refused

Ouvrez Desktop, activez l’API, appliquez les réglages et vérifiez le port. Gardez Desktop ouvert.

401

Vérifiez la clé API Bearer et mettez vos scripts à jour après sa régénération.

400

Lisez error et skipped. Vérifiez les chemins absolus, noms de presets, extensions et état de la tâche.

404

Vérifiez la route /api, le jobId et l’index de results. L’historique est temporaire et les fichiers peuvent ne plus exister localement.

412

Connectez Google Drive dans les réglages Desktop et vérifiez GET /api/drive/status.

429

La file contient déjà 10 tâches en attente. Consultez GET /api/jobs et attendez avant une autre création.

Connexion fermée / 500

Un corps de requête ou fichier trop volumineux, ou une erreur disque, peut fermer la connexion. Respectez les limites et vérifiez les droits du dossier de sortie. Consultez l’historique avant de relancer une création dont la réponse a été perdue.

Besoin d’aide pour votre workflow ?

Le support MetaGhost peut vous aider.

Support

Contrat revu le 10 septembre 2026 · Desktop 1.0.81