Automatiser la conversion d'images avec l'API Morphix

Convertir manuellement des images une par une fonctionne quand vous avez cinq fichiers. Quand vous en avez cinq cents, ou quand de nouvelles images arrivent chaque jour, vous avez besoin d'automatisation. L'API Morphix transforme le traitement d'images en un simple appel HTTP, ce qui signifie que tout script, outil de build ou pipeline CI/CD peut s'en charger.

Ce guide montre comment mettre en place la conversion en lot, combiner les opérations, et intégrer le traitement d'images dans votre workflow de développement.

Pourquoi automatiser la conversion d'images ?

Le traitement manuel d'images ne passe pas à l'échelle. Voici les scénarios où l'automatisation se rentabilise immédiatement :

Catalogues e-commerce. Un catalogue produit de 500 images nécessite chaque image en WebP, AVIF et JPG, en trois tailles (miniature, listing, taille complète). Soit 4 500 fichiers en sortie. Le faire à la main n'est pas réaliste.

Publication de contenu. Un blog ou site d'actualités qui publie quotidiennement a besoin que chaque image uploadée soit convertie en formats modernes, redimensionnée pour les breakpoints responsive, et nettoyée de ses métadonnées. Le traitement manuel crée un goulot d'étranglement et introduit de l'inconsistance.

Contenu généré par les utilisateurs. Toute plateforme qui accepte des uploads d'images (marketplaces, forums, apps sociales) doit normaliser les images : format cohérent, dimensions cohérentes, métadonnées supprimées pour la vie privée.

Pipelines de build. Les sites statiques, les sites de documentation et les applications web qui incluent des images dans leur processus de build bénéficient de la conversion automatisée comme étape de build. Chaque nouvelle image est automatiquement optimisée sans intervention du développeur.

Préparer son environnement

Vous avez besoin de deux choses : une clé API et un outil capable de faire des requêtes HTTP.

Obtenez votre clé API depuis le tableau de bord Morphix. Stockez-la dans une variable d'environnement :

export MORPHIX_API_KEY="votre_cle_ici"

Choisissez votre outil. Les exemples de ce guide utilisent cURL (pour les scripts Bash) et Python (pour les workflows plus complexes). Tout langage fonctionne, l'API est un endpoint REST standard.

Testez votre configuration avec une conversion unique :

curl -X POST https://morphix.tools/api/v1/convert \
  -H "Authorization: Bearer $MORPHIX_API_KEY" \
  -F "file=@test.jpg" \
  -F "format=webp" \
  -F "quality=80" \
  --output test.webp

Si vous obtenez un fichier WebP en retour, votre configuration fonctionne.

Convertir un dossier d'images en lot

La tâche d'automatisation la plus courante est de convertir chaque image d'un répertoire vers un nouveau format.

Script Bash :

#!/bin/bash
INPUT_DIR="./images/originaux"
OUTPUT_DIR="./images/webp"
mkdir -p "$OUTPUT_DIR"

for file in "$INPUT_DIR"/*.{jpg,jpeg,png}; do
  [ -f "$file" ] || continue
  filename=$(basename "${file%.*}")
  
  curl -s -X POST https://morphix.tools/api/v1/convert \
    -H "Authorization: Bearer $MORPHIX_API_KEY" \
    -F "file=@$file" \
    -F "format=webp" \
    -F "quality=80" \
    --output "$OUTPUT_DIR/$filename.webp"
  
  echo "Converti : $filename.webp"
done

Script Python avec gestion d'erreurs :

import os
import requests
from pathlib import Path

API_KEY = os.environ["MORPHIX_API_KEY"]
API_URL = "https://morphix.tools/api/v1/convert"
INPUT_DIR = Path("./images/originaux")
OUTPUT_DIR = Path("./images/webp")
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

for image_path in INPUT_DIR.glob("*"):
    if image_path.suffix.lower() not in (".jpg", ".jpeg", ".png"):
        continue

    with open(image_path, "rb") as f:
        response = requests.post(
            API_URL,
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": f},
            data={"format": "webp", "quality": 80},
        )

    if response.status_code == 200:
        output_path = OUTPUT_DIR / f"{image_path.stem}.webp"
        output_path.write_bytes(response.content)
        print(f"OK : {image_path.name} -> {output_path.name}")
    else:
        print(f"ECHEC : {image_path.name} ({response.status_code})")

Les deux scripts parcourent chaque JPG et PNG du répertoire d'entrée, convertissent en WebP à qualité 80, et sauvegardent le résultat dans le répertoire de sortie.

Redimensionner et convertir en un seul flux

Vous pouvez enchaîner les opérations en faisant des appels API séquentiels. Un workflow courant est de convertir en WebP puis redimensionner à plusieurs breakpoints :

import os
import requests
from pathlib import Path

API_KEY = os.environ["MORPHIX_API_KEY"]
BASE_URL = "https://morphix.tools/api/v1"
SIZES = [
    {"width": 400, "height": 300, "suffix": "sm"},
    {"width": 800, "height": 600, "suffix": "md"},
    {"width": 1200, "height": 900, "suffix": "lg"},
]

def process_image(image_path, output_dir):
    with open(image_path, "rb") as f:
        webp_response = requests.post(
            f"{BASE_URL}/convert",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": f},
            data={"format": "webp", "quality": 80},
        )

    if webp_response.status_code != 200:
        print(f"Conversion echouee : {image_path.name}")
        return

    for size in SIZES:
        resize_response = requests.post(
            f"{BASE_URL}/resize",
            headers={"Authorization": f"Bearer {API_KEY}"},
            files={"file": ("image.webp", webp_response.content, "image/webp")},
            data={"width": size["width"], "height": size["height"]},
        )

        if resize_response.status_code == 200:
            name = f"{image_path.stem}-{size['suffix']}.webp"
            (output_dir / name).write_bytes(resize_response.content)
            print(f"OK : {name}")

Cela produit trois fichiers WebP par image source : petit (400x300), moyen (800x600) et grand (1200x900).

Intégration dans un pipeline de build

Pour les sites statiques et les applications web, ajoutez la conversion d'images comme étape de build qui s'exécute automatiquement à chaque déploiement.

Exemple Makefile :

.PHONY: images
images:
	@echo "Conversion des images en WebP..."
	@./scripts/convert-images.sh
	@echo "Terminé."

build: images
	npm run build

Exemple GitHub Actions :

- name: Convertir les images en WebP
  env:
    MORPHIX_API_KEY: ${{ secrets.MORPHIX_API_KEY }}
  run: |
    for file in public/images/originals/*.{jpg,png}; do
      [ -f "$file" ] || continue
      filename=$(basename "${file%.*}")
      curl -s -X POST https://morphix.tools/api/v1/convert \
        -H "Authorization: Bearer $MORPHIX_API_KEY" \
        -F "file=@$file" \
        -F "format=webp" \
        -F "quality=80" \
        --output "public/images/webp/$filename.webp"
    done

Stockez votre clé API comme secret du dépôt, jamais dans le code.

Monitoring et gestion d'erreurs

L'automatisation en production nécessite de la gestion d'erreurs. Voici les patterns essentiels :

Retry sur 429 (limite de débit). Lisez le header X-RateLimit-Reset et attendez avant de réessayer :

import time

def api_call_with_retry(url, headers, files, data, max_retries=3):
    for attempt in range(max_retries):
        response = requests.post(url, headers=headers, files=files, data=data)
        if response.status_code == 429:
            reset_time = int(response.headers.get("X-RateLimit-Reset", 0))
            wait = max(reset_time - int(time.time()), 1)
            print(f"Limite atteinte. Attente {wait}s...")
            time.sleep(wait)
            continue
        return response
    return response

Logguez les échecs. Suivez quelles images ont échoué pour pouvoir les retraiter sans retraiter tout le lot.

Validez la sortie. Vérifiez que le statut de réponse est 200 et que le content-type correspond au format attendu avant de sauvegarder le fichier.

Obtenez votre clé API

Créez votre clé API depuis le tableau de bord Morphix. Aucune carte bancaire requise pour le plan gratuit.

Documentation API | Créer un compte

Automatiser le traitement d'images à grande échelle avec l'API Morphix