> [Site index](https://perfectvector.com/llms.txt) — available pages and descriptions.

# Vectoriser une image en Python avec une API

> Envoyez un PNG, JPEG ou WebP à une API de vectorisation en Python. Enregistrez le SVG, vérifiez une réponse de test et récupérez la conversion en cas de coupure.

Source: https://perfectvector.com/fr/blog/vectorize-image-python-api

Language: fr
Author: Jay
Published: 2026-11-09T08:00:00+09:00

Un script Python peut envoyer une image matricielle à l'API PerfectVector et enregistrer le SVG obtenu à côté de la source. L'exemple affiche l'identifiant de conversion avant de télécharger le fichier. Si la connexion se coupe, vous pouvez récupérer le résultat avec cet identifiant ou la clé de requête que vous avez choisie.

## Préparez une clé de test et une image

Créez une clé de test depuis la [page de l'API pour les développeurs](https://perfectvector.com/account/developers). Définissez-la dans le terminal sous `PERFECTVECTOR_API_KEY` et ne l'ajoutez ni au script ni au contrôle de version. Installez Requests dans l'environnement Python du projet avec `python -m pip install requests`.

Au premier essai, prenez un PNG, JPEG ou WebP à une seule image, par exemple un logo de 512 × 512 pixels nommé `logo.png`. L'API accepte jusqu'à 5 Mio et de 100 à 4096 pixels de chaque côté. Le mode test valide l'envoi et renvoie gratuitement un SVG fixe marqué « TEST MODE ». Le fichier vérifie la requête et le téléchargement. Pour juger la qualité du tracé de votre image, lancez une conversion en production. [Mode test de l'API PerfectVector](https://perfectvector.com/docs/api/test-mode)

Nous avons exécuté le script avec une clé de test, téléchargé un SVG valide et répété l'envoi avec la même clé de requête. Les deux exécutions ont donné le même identifiant.

**Schéma du processus**

![Un fichier matriciel local passe par une requête identifiée vers un service distant et revient sous forme de fichier vectoriel sur le disque.](https://perfectvector.com/blog/vectorize-image-python-api/workflow.webp)

*Conservez la clé avec l'envoi et enregistrez l'identifiant de conversion avant de télécharger le SVG.*

## Envoyez l'image et enregistrez le SVG en Python

Enregistrez le script sous `vectorize.py`. L'argument `files` indique à Requests de créer un envoi multipart, avec les données d'origine dans le champ `image`. [Envois multipart avec Requests](https://requests.readthedocs.io/en/latest/user/quickstart/#post-a-multipart-encoded-file)

```python
import os
import sys
import time
from pathlib import Path

import requests

API = "https://api.perfectvector.com/v1"
AUTH = {"Authorization": f"Bearer {os.environ['PERFECTVECTOR_API_KEY']}"}


def checked(response):
    content_type = response.headers.get("Content-Type", "").split(";")[0]
    if response.status_code >= 400 and content_type == "application/problem+json":
        problem = response.json()
        raise RuntimeError(f"{problem['code']} (request {problem['request_id']})")
    response.raise_for_status()
    return response


def vectorize(source, destination, operation_id):
    with source.open("rb") as image:
        response = checked(requests.post(
            f"{API}/vectorizations",
            headers={**AUTH, "Idempotency-Key": operation_id, "Prefer": "wait=10"},
            files={"image": (source.name, image)},
            timeout=30,
        ))

    conversion = response.json()
    conversion_id = conversion["id"]
    print(f"Conversion ID: {conversion_id}", flush=True)
    deadline = time.monotonic() + 720
    while conversion["status"] in {"queued", "processing"}:
        if time.monotonic() >= deadline:
            raise TimeoutError(f"Stopped polling {conversion_id}")
        time.sleep(2)
        conversion = checked(requests.get(
            f"{API}/vectorizations/{conversion_id}", headers=AUTH, timeout=30,
        )).json()

    if conversion["status"] != "succeeded":
        error = conversion["results"][0].get("error") or {}
        raise RuntimeError(f"{conversion_id}: {error.get('code', conversion['status'])}")

    svg = checked(requests.get(
        f"{API}/vectorizations/{conversion_id}/result", headers=AUTH, timeout=30,
    ))
    if svg.headers.get("Content-Type", "").split(";")[0] != "image/svg+xml":
        raise ValueError("Expected an SVG response")
    partial = destination.with_suffix(".svg.part")
    partial.write_bytes(svg.content)
    partial.replace(destination)
    print(f"{destination} saved ({len(svg.content)} bytes)")


if __name__ == "__main__":
    source = Path(sys.argv[1])
    if source.suffix.lower() not in {".png", ".jpg", ".jpeg", ".webp"}:
        raise SystemExit("Choose a PNG, JPEG or WebP file")
    if source.stat().st_size > 5 * 1024 * 1024:
        raise SystemExit("Choose a file no larger than 5 MiB")
    vectorize(source, source.with_suffix(".svg"), sys.argv[2])
```

Lancez la commande dans le dossier qui contient `logo.png`. Choisissez un identifiant pour cette conversion et notez-le avant l'exécution. L'API l'appelle *clé d'idempotence*. Cette valeur rattache les renvois d'un même fichier à une seule conversion. L'exemple utilise `logo-asset-0001`. Choisissez une valeur différente pour une autre image ou opération. [Répéter une requête sans risque chez PerfectVector](https://perfectvector.com/docs/api/idempotency)

```bash
python vectorize.py logo.png logo-asset-0001
```

Un test réussi affiche l'identifiant de conversion et le nombre d'octets, puis enregistre `logo.svg` à côté de `logo.png`. Ouvrez `logo.svg` pour vérifier le rendu. Le script remplace un SVG du même nom après avoir téléchargé le nouveau fichier. Utilisez un dossier temporaire pour le premier essai.

Le script demande au serveur d'attendre jusqu'à 10 secondes avant de renvoyer une conversion non terminée. Il vérifie les conversions `queued` et `processing` environ toutes les deux secondes et télécharge seulement à l'état `succeeded`. Une conversion de test se termine immédiatement. Simulez une réponse en attente dans un test local avant d'utiliser cette branche en production. [Attente et réponses asynchrones chez PerfectVector](https://perfectvector.com/docs/api/waiting-and-async)

## Récupérez une conversion après expiration du délai

Si Python a affiché un identifiant de conversion, vérifiez-le avec `GET /v1/vectorizations/{id}`. Une fois la conversion réussie, utilisez `GET /v1/vectorizations/{id}/result` dans le même compte et le même mode pour télécharger le SVG. Les liens expirent 24 heures après la fin du traitement. Copiez le fichier dans votre espace de stockage si vous en aurez besoin plus tard. [Télécharger les résultats PerfectVector](https://perfectvector.com/docs/api/results)

Si Python s'arrête avant d'afficher l'identifiant, relancez la commande avec les mêmes données et la même clé d'idempotence dans les 24 heures suivant la première requête. L'API renvoie la conversion existante si elle a accepté le premier envoi. Passé ce délai, un envoi avec la même clé peut lancer une nouvelle conversion. [Répéter une requête sans risque chez PerfectVector](https://perfectvector.com/docs/api/idempotency)

| Ce que vous voyez                                         | Ce qu'il faut vérifier                                                                                                                             |
| --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| `401 invalid_api_key`                                     | Définissez une clé de test valide dans l'environnement Python. Si vous l'avez révoquée, créez une autre clé du même mode.                          |
| `415 unsupported_media_type` ou `422 invalid_image`       | Ouvrez l'original et contrôlez le format réel et les dimensions en pixels. Enregistrez le fichier corrigé et attribuez une nouvelle clé à l'envoi. |
| Un identifiant de conversion suivi de `processing_failed` | L'API a créé un enregistrement mais n'a pas pu vectoriser l'image. Examinez l'original et renvoyez un fichier corrigé comme nouvelle opération.    |
| `409 idempotency_conflict`                                | La même clé a été utilisée avec d'autres données ou options. Reprenez avec l'original ou donnez une nouvelle clé à la nouvelle entrée.             |

Si vous contactez l'assistance, conservez l'identifiant de requête de l'exception ou l'identifiant de conversion du script. La [référence des erreurs de l'API](https://perfectvector.com/docs/api/errors) indique quand un nouvel essai est possible.

## Questions fréquentes

### Le même script Python accepte-t-il un JPEG ou un WebP ?

Oui. Passez le JPEG ou WebP en premier argument. Les mêmes règles de taille, de dimensions et d'image unique s'appliquent. La sortie porte l'extension SVG.

### Puis-je utiliser cet exemple pour tout un dossier ?

Vérifiez d'abord un envoi et un téléchargement. Pour un dossier, conservez la clé, l'identifiant et le chemin de sortie de chaque fichier dans une file persistante. PerfectVector autorise par défaut une conversion en production à la fois par compte. Attendez la fin de chacune avant d'envoyer la suivante. [Limites de l'API PerfectVector](https://perfectvector.com/docs/api/limits)

## Sources

1. [Requests — Démarrage rapide](https://requests.readthedocs.io/en/latest/user/quickstart/) — Fichiers multipart, délais et réponses binaires.
2. [PerfectVector — Mode test](https://perfectvector.com/docs/api/test-mode) — Limites d'envoi, SVG fixe et crédits en mode test.
3. [PerfectVector — Attente et réponses asynchrones](https://perfectvector.com/docs/api/waiting-and-async) — Préférence d'attente, vérification d'état et fin d'une requête de test.
4. [PerfectVector — Idempotence](https://perfectvector.com/docs/api/idempotency) — Durée, portée, conflits et règles de renvoi.
5. [PerfectVector — Résultats](https://perfectvector.com/docs/api/results) — Point d'accès, authentification et expiration.
6. [PerfectVector — Erreurs](https://perfectvector.com/docs/api/errors) — Codes de problème HTTP et procédure de récupération.
7. [PerfectVector — Limites](https://perfectvector.com/docs/api/limits) — Simultanéité en production et limites de fichiers.

***

[Obtenez une clé de test depuis la page de l'API PerfectVector](https://perfectvector.com/fr/api) et exécutez le script avec une de vos images. Vérifiez que le SVG enregistré s'ouvre et que le terminal affiche son identifiant de conversion.

## Explore

- [Read the HTML article](https://perfectvector.com/fr/blog/vectorize-image-python-api)
- [Meilleurs vectoriseurs d’images IA 2026 : nos choix par usage](https://perfectvector.com/fr/blog/best-ai-vectorizers-2026.md)
- [Convertir un dossier en SVG par lot avec Claude Code](https://perfectvector.com/fr/blog/batch-vectorize-images-claude-code-mcp.md)
- [Product facts](https://perfectvector.com/product-facts.md)
- [FAQ](https://perfectvector.com/faq.md)
- [Pricing and credits](https://perfectvector.com/pricing.md)