DEV Community: Antoine Laurent

Automatiser sa recherche d'emploi avec l'IA Open Source (Guide Career-Ops)

Antoine Laurent — Tue, 07 Apr 2026 10:07:38 +0000

TL;DR

Career-Ops est un boilerplate open source qui transforme Claude Code en un centre de commande pour la recherche d'emploi. Il évalue les offres (note A à F), génère des CV optimisés pour les ATS et adaptés à chaque annonce, scanne automatiquement plus de 45 portails d'entreprise, et suit tout dans un tableau de bord terminal. Le créateur l'a utilisé pour évaluer 740+ offres et décrocher un poste de Head of Applied AI.

Essayez Apidog dès aujourd'hui

Introduction

La plupart des développeurs suivent leurs candidatures dans un tableur. Vous ouvrez un nouvel onglet, collez une description de poste, cherchez des mots-clés, mettez à jour une ligne avec "Candidature envoyée, en attente." Vous répétez ça 50 fois et le processus devient un second job.

Career-Ops inverse ce modèle. Au lieu de tout faire manuellement, déléguez à Claude Code : collez une URL ou une description de poste, le système lit votre CV, évalue l'adéquation, note l’offre sur 10 dimensions, génère un PDF personnalisé et sauvegarde le résultat. À vous de décider de postuler.

Ce n'est pas un bot de candidatures massives. Le système filtre et recommande uniquement ce qui vaut le coup (seuil de 4.0/5). Son créateur, Santiago Fernández de Valderrama, a évalué plus de 740 offres, généré 100+ CV personnalisés, décroché un poste de Head of Applied AI, et le projet a atteint 11 900 étoiles GitHub en moins d’une semaine.

💡 Tip : Si vous développez ou testez des API, les Scénarios de Test d'Apidog vous permettent de vérifier chaque appel HTTP que Career-Ops effectue vers les API des sites d'emploi, avant toute mise en production. Voir [internal: api-testing-tutorial] pour une approche complète.

Ce que Career-Ops fait réellement

Career-Ops est un boilerplate Claude Code. Ce n'est pas une application autonome.

Mise en place rapide :

Clonez le dépôt.
Ajoutez votre CV en markdown.
Configurez votre profil YAML.
Ouvrez Claude Code dans ce dossier.

Une commande slash exécute tout le pipeline.

Workflow principal :

Vous collez une URL ou une description de poste
        |
        v
Détection de l'archétype
(LLMOps / Agentique / PM / SA / FDE / Transformation)
        |
        v
Moteur d'évaluation A-F
(lit votre cv.md, note 10 dimensions)
        |
   +----+----+
   v    v    v
Rapport  PDF  Suivi
 .md   .pdf  .tsv

L'exécution se fait dans Claude Code, qui lit/modifie ses propres fichiers de configuration : modes, pondérations, scripts de négociation.

Les 14 commandes slash

Le point d’entrée : /career-ops avec 14 modes clés.

/career-ops                 → Liste toutes les commandes
/career-ops {description}   → Évaluation complète : scoring + PDF + suivi
/career-ops scan            → Scanner 45+ portails d'entreprise
/career-ops pdf             → Générer un CV ATS pour une annonce
/career-ops batch           → Évaluer 10+ offres en parallèle
/career-ops tracker         → Statut du pipeline de candidatures
/career-ops apply           → Remplir des formulaires de candidature avec l'IA
/career-ops pipeline        → Traiter une file d’attente d’URL
/career-ops contacto        → Messages de prospection LinkedIn
/career-ops deep            → Recherche approfondie entreprise
/career-ops training        → Évaluer un cours/certif
/career-ops project         → Évaluer un projet de portfolio

La commande principale : collez l’URL d’un poste, Career-Ops gère tout. L’auto-détection de mode permet de simplement insérer la description brute pour déclencher l’évaluation.

Comment fonctionne le moteur de notation A-F

Le cœur du système : chaque offre est analysée via 6 blocs structurés.

Bloc A : Résumé du rôle. Extraction du titre, équipe, séniorité, compétences, archétype.
Bloc B : Adéquation du CV. Analyse de votre profil versus l’annonce, au-delà des mots-clés. Met en évidence lacunes et points forts.
Bloc C : Stratégie niveau/rémunération. Recherche des fourchettes salariales, prépare les arguments de négociation.
Bloc D : Personnalisation. Génère les points pour lettre de motivation/prospection, adaptés à l’entreprise.
Bloc E : Score (A-F). Score global (recommandé : postuler uniquement si >4.0/5).
Bloc F : Préparation entretien (STAR+R). Génère des récits STAR stockés dans story-bank.md, pour constituer une bibliothèque réutilisable.

Des scripts de négociation (ancrage salarial, refus de réduction géographique, argumentaires d’offres concurrentes) sont aussi générés.

Génération de PDF optimisés ATS

Le générateur PDF adapte votre CV à chaque annonce :

Analyse la description pour extraire mots-clés et exigences.
Réécrit vos expériences pour mettre en avant ces mots-clés, sans rien inventer.
Génère un PDF via Playwright/Puppeteer avec un template HTML (polices Space Grotesk & DM Sans).

Exemple d’utilisation :

# Générer un CV personnalisé pour une annonce
/career-ops pdf

# Ou via le pipeline complet
/career-ops {URL ou description du poste}

Les PDF sont placés dans output/, ignoré par Git pour préserver vos données.

Scan de portails à grande échelle

Career-Ops intègre 45+ entreprises IA/scalups configurées pour le scan automatique :

Laboratoires IA: Anthropic, OpenAI, Mistral, etc.
IA vocale: ElevenLabs, PolyAI, Parloa, etc.
Plateformes IA: Retool, Airtable, Vercel, etc.
LLMOps: Langfuse, W&B, Lindy, etc.
Entreprise: Salesforce, Twilio, Gong, etc.
Automatisation: n8n, Zapier, Make.com
DACH/Europe: Factorial, Attio, Tinybird, +31 entreprises DACH

Le scanner utilise Playwright pour extraire les offres sur les pages carrière et interroge directement les API de Greenhouse, Ashby, Lever, Wellfound. Configurez vos cibles dans portals.yml, puis lancez :

/career-ops scan

Les nouvelles offres sont intégrées automatiquement dans votre pipeline.

Traitement par lots avec des sous-agents parallèles

Pour traiter rapidement un backlog d’offres :

# Déposez les URLs dans le dossier jds/
# Puis lancez :
/career-ops batch

Sous le capot, des workers claude -p traitent chaque offre en parallèle. Résultats fusionnés et dédupliqués automatiquement. Le script batch/batch-runner.sh orchestre le tout et gère les échecs.

Ce mode permet d’évaluer 20 offres en moins d’une heure, contre une journée en manuel.

Tableau de bord TUI en Go

Le suivi des candidatures est stocké dans data/applications.md (tableau markdown).

Le dashboard terminal (Go + Bubble Tea, thème Catppuccin Mocha) offre :

6 filtres (statut, archétype, score)
4 modes de tri
Vue groupée ou plate
Aperçus différés des rapports
Changement de statut en ligne

cd dashboard
go build -o career-dashboard .
./career-dashboard

Mettez à jour le statut d’une candidature directement dans le TUI, sans toucher au markdown.

Configuration en 15 minutes

Procédure :

# 1. Cloner et installer
git clone https://github.com/santifer/career-ops.git
cd career-ops && npm install
npx playwright install chromium

# 2. Configurer le profil
cp config/profile.example.yml config/profile.yml
# Éditez profile.yml (nom, lieu, rôle, salaire, préférences)

# 3. Configurer les entreprises
cp templates/portals.example.yml portals.yml
# Modifiez la liste dans portals.yml

# 4. Ajoutez votre CV
# Créez cv.md à la racine, collez votre CV (markdown)

# 5. Ouvrir Claude Code
claude
# Exemples de commandes :
# "Changer les archétypes en rôles backend"
# "Ajouter ces entreprises à portals.yml"
# "Mettre à jour mon profil avec ce CV"

Claude peut modifier les fichiers système pour personnaliser modes, pondérations et scripts, sur simple demande.

Mise à jour automatique

Version 1.1.0 : deux couches (fichiers système vs utilisateur). Les mises à jour ne touchent que la couche système.

# Vérifier les mises à jour
node update-system.mjs check

# Appliquer mise à jour
node update-system.mjs apply

# Annuler
node update-system.mjs rollback

Une branche de sauvegarde est créée à chaque mise à jour. Vérification automatique de l’intégrité des données utilisateur.

Différences avec les autres outils

Pas de bot de candidatures, mais un système d’aide à la décision. Ne postulez pas <4.0/5, économisez votre temps.
Analyse réelle de l’adéquation, pas seulement des mots-clés. Le raisonnement prime.
S’améliore avec le contexte fourni. Plus votre profil est enrichi, plus l’évaluation est pertinente.
Toutes vos données restent locales. Rien n’est envoyé ailleurs (hors appels API nécessaires à l’évaluation).

Limitations à connaître

Nécessite Claude Code. Non compatible avec d'autres modèles/interfaces.
Playwright dépendant des portails. Fonctionne mieux sur Greenhouse/Ashby/Lever ; pages custom parfois instables.
Étalonnage initial obligatoire. Prévoyez une heure pour configurer le profil et fournir contexte/preuves.
Batch = consommation rapide de crédits API. Surveillez votre quota avant un traitement de masse.

Voir [internal: how-ai-agent-memory-works] pour comprendre l’importance du contexte et de l’étalonnage.

Pour qui ?

Career-Ops s’adresse aux devs/profils techniques qui :

Cherchent activement un job et veulent automatiser le suivi
Visent des rôles dans des entreprises d’IA
Veulent l’IA comme assistant d’évaluation/filtrage, pas comme bot de candidature
Sont à l’aise avec le CLI et l’édition YAML

Non adapté : utilisateurs non techniques, recherche d’interface graphique, automatisation de la soumission des candidatures (cette étape reste manuelle).

Pour commencer

Clonez le repo, ajoutez votre CV, passez 1h à configurer votre profil avec Claude, puis réalisez une première évaluation sur une offre pertinente. L’étalonnage initial est vite rentabilisé.

GitHub : github.com/santifer/career-ops

Licence MIT, contributions bienvenues (ouvrir une issue avant PR).

Conclusion

Career-Ops est aujourd’hui le pipeline open source de recherche d’emploi le plus complet : notation A-F, génération PDF ATS, traitement batch parallèle, dashboard TUI Go. Avec un profil bien calibré, vous filtrez efficacement et ne postulez que là où cela a du sens.

La recherche d’emploi est un problème d’information, pas de volume. Career-Ops traite le problème sous cet angle.

FAQ

Career-Ops est-il payant ?

Non, licence MIT. Vous payez uniquement l’API Claude selon usage (10k-30k tokens/évaluation complète, soit <0,05 $/évaluation).

Compatible avec d’autres modèles que Claude ?

Non. Boilerplate dédié Claude Code. Portage nécessiterait de réécrire les définitions de compétences.

Optimisation ATS, comment ça marche ?

Lecture de l’offre, extraction de mots-clés, réécriture des expériences pour coller naturellement au wording du poste. Pas d’invention. PDF généré via Playwright avec polices compatibles ATS.

Quels portails sont supportés ?

Greenhouse, Ashby, Lever, Wellfound, Workable, RemoteFront nativement. Pour les autres, Playwright scrappe la page carrière. 31 entreprises DACH/UE ajoutées par la communauté. Voir [internal: local-vs-api-ai-models] pour plus d’infos sur la gestion multi-API.

Mes données CV sont-elles sécurisées ?

Oui, tout est local par défaut (CV, candidatures, PDF, rapports ignorés par Git). Seuls les appels API nécessaires à l’évaluation sortent (vers l’API Anthropic). Voir [internal: claude-code] pour plus d’infos.

Peut-on ajouter ses propres entreprises au scanner ?

Oui. Copiez templates/portals.example.yml vers portals.yml et ajoutez vos entreprises. Si Greenhouse/Ashby/Lever, détection auto via API. Pour les pages custom, définissez des sélecteurs Playwright.

Combien de temps pour une évaluation complète ?

2-4 min avec Claude 3.5 Sonnet. En batch, 10 offres traitées en parallèle en 2-4 min.

Qu’est-ce que le cadre STAR+R ?

STAR = Situation, Tâche, Action, Résultat. +R = Réflexion (ce que vous feriez différemment, ce que vous avez appris). Career-Ops ajoute cette colonne pour signaler la séniorité.

Meilleurs assistants de codage open source en 2026: Alternatives gratuites à Cursor

Antoine Laurent — Tue, 07 Apr 2026 10:01:31 +0000

En bref

Cursor coûte 20 $/mois. Windsurf coûte 15 $/mois. Cinq alternatives open source égalent désormais 80 % des fonctionnalités gratuitement, y compris le codage agentique, les modifications multi-fichiers et la flexibilité "apportez votre propre modèle". Ce guide couvre les meilleures, ce pour quoi chacune est réellement bonne et comment choisir.

Essayez Apidog dès aujourd'hui

Introduction

Il y a un an, "assistant de codage open source" désignait un plugin de complétion de code qui suggérait la ligne suivante. Aujourd'hui, il s'agit d'un environnement de codage agentique complet capable de lire votre base de code, d'écrire des tests, d'exécuter des commandes terminales et d'itérer sur sa propre sortie.

L'écart entre les outils payants et les alternatives gratuites s'est considérablement réduit. Cursor reste la référence en matière de codage agentique, mais à 20 $/mois par développeur, cela s'additionne rapidement pour les équipes. Windsurf, à 15 $/mois, est une alternative solide. GitHub Copilot, à 10 $/mois, bénéficie de la plus large adoption. Les trois sont propriétaires. Vous ne pouvez pas auditer le code, vous ne pouvez pas les auto-héberger, et vous êtes lié à leurs choix de modèles.

Les outils open source présentés dans cet article vous offrent une flexibilité de modèle, une auditabilité complète et zéro frais d'abonnement. Le compromis est le temps de configuration et, dans certains cas, une expérience utilisateur moins raffinée.

💡Une chose qu'aucun de ces outils ne fait : tester les API que votre code généré par l'IA appelle. C'est là qu'Apidog intervient. Une fois qu'un assistant de codage IA écrit un client REST ou génère des points de terminaison conformes à la spécification OpenAPI, les scénarios de test d'Apidog vous permettent de vérifier ces intégrations avant qu'elles n'atteignent la production. Consultez [internal: api-testing-tutorial] pour le workflow de test.

Pourquoi les assistants de codage open source sont viables en 2026

Trois choses ont changé.

Accès aux modèles : OpenAI, Anthropic et Google offrent tous un accès API à leurs modèles de pointe. Un outil open source avec une bonne UX peut offrir le même modèle sous-jacent que Cursor ; il ne vient juste pas avec l'enveloppe propriétaire. Des outils comme Continue.dev et Cline vous permettent de brancher directement Claude 3.5 Sonnet, GPT-4o ou Gemini 1.5 Pro.

Modèles locaux : Ollama a rendu trivial l'exécution locale de Qwen2.5-Coder, DeepSeek-Coder-V2 et Code Llama. Pour les bases de code sensibles où vous ne pouvez pas envoyer de code à une API externe, les modèles locaux sont désormais véritablement utilisables pour les tâches de codage.

Architecture d'agent : L'API d'utilisation d'outils de Claude et l'appel de fonctions de GPT-4o ont standardisé le fonctionnement des agents de codage. Les frameworks open source peuvent reproduire la même boucle de lecture de fichiers/écriture de fichiers/exécution de terminal qui alimente le mode agent de Cursor.

Les 5 meilleurs assistants de codage open source

1. Continue.dev

Qu'est-ce que c'est : une extension VS Code et JetBrains qui ajoute une barre latérale de chat, des modifications en ligne et une fonction de questions-réponses consciente de la base de code. L'option open source la plus mature.

Idéal pour : les développeurs qui souhaitent une expérience similaire à Cursor dans VS Code sans quitter leur configuration existante. Excellent pour les équipes qui veulent contrôler le modèle qu'elles utilisent.

Configuration :

Installez depuis la marketplace VS Code.
Ajoutez votre clé API (OpenAI, Anthropic, Gemini ou Ollama local).
Aucun compte requis.

Ce qu'il peut faire :

Chat contextuel avec indexation complète de la base de code
Modifications en ligne via Ctrl+I
Recherche @codebase sur l'ensemble du dépôt
Commandes slash et fournisseurs de contexte personnalisés
Fonctionne avec plus de 20 fournisseurs de modèles

Limitations : pas d'exécution de terminal intégrée ni de boucle d'agent autonome. C'est un assistant, pas un agent. Vous approuvez chaque modification manuellement.

Coût : gratuit. Auto-hébergé ou utilisez vos propres clés API.

	Cursor	Continue.dev
Prix	20 $/mois	Gratuit
Support VS Code	Oui	Oui
Support JetBrains	Non	Oui
Flexibilité du modèle	Limitée	Complète
Mode Agent	Oui	Partiel
Idéal pour	Codage agentique complet	Édition assistée avec contrôle du modèle

2. Aider

Qu'est-ce que c'est : un agent de codage basé sur le terminal qui utilise Git comme interface principale. Vous décrivez ce que vous voulez, Aider lit les fichiers pertinents, apporte des modifications et les commite.

Idéal pour : les ingénieurs backend qui travaillent dans le terminal et souhaitent un agent de codage autonome qu'ils peuvent exécuter dans un pipeline CI ou sur un serveur distant.

Configuration :

pip install aider-chat
aider --model claude-3-5-sonnet-20241022

(à lancer depuis la racine de votre projet)

Ce qu'il peut faire :

Modifications multi-fichiers autonomes avec des commits Git
Fonctionne avec Claude, GPT-4o, Gemini et les modèles locaux
Flag --yes pour un fonctionnement entièrement automatisé
Lit la carte du dépôt pour comprendre la structure de la base de code
Prise en charge de la saisie vocale
Suite de benchmarks intégrée (aider-bench)

Limitations : uniquement en terminal. Pas d'intégration IDE. L'absence d'une vue de diff visuelle rend l'examen des modifications importantes difficile.

Coût : gratuit. Paiement à l'utilisation pour l'API du modèle sous-jacent.

Exemple pratique : exécutez Aider dans un workflow GitHub Actions pour corriger automatiquement les tests échoués :

- name: Run Aider to fix tests
  run: |
    aider --model gpt-4o \
          --message "Fix the failing tests in test_api.py" \
          --yes \
          --no-git

3. Cline

Qu'est-ce que c'est : une extension VS Code qui exécute une boucle d'agent complète avec utilisation d'outils. Cline peut lire des fichiers, écrire des fichiers, exécuter des commandes terminales, naviguer sur le web et utiliser votre navigateur. C'est l'équivalent open source le plus proche du mode agent complet de Cursor.

Idéal pour : les développeurs qui souhaitent des tâches de codage autonomes et multi-étapes gérées de bout en bout dans VS Code.

Configuration :

Installez depuis la marketplace VS Code.
Ajoutez votre clé API.
Démarrez une nouvelle tâche.

Ce qu'il peut faire :

Boucle agentique complète : lecture, écriture, exécution, navigation
Mode approbation : vous approuvez chaque action avant qu'elle ne s'exécute (ou définissez-la sur auto-approbation)
Flexibilité du modèle : Claude, GPT-4o, Gemini, Bedrock, Vertex, Ollama local
Suivi des coûts par tâche (utile lors de l'utilisation de modèles de pointe coûteux)
Injection de prompt système personnalisé

Limitations : peut devenir coûteux avec les modèles de pointe sur des tâches longues car la boucle de l'agent envoie le contexte complet à chaque étape. Surveillez vos coûts.

Coût : gratuit. Payez votre fournisseur de modèle directement.

4. Modo

Qu'est-ce que c'est : un nouveau projet open source apparu en avril 2026 comme une alternative explicite à Cursor, Kiro et Windsurf. C'est un IDE complet construit sur le cœur de VS Code avec le codage IA intégré.

Idéal pour : les développeurs qui veulent un IDE dédié axé sur l'IA sans abonnement. Encore en phase précoce, mais la trajectoire est prometteuse.

Configuration :

git clone https://github.com/mohshomis/modo.git
cd modo
npm install && npm run build

Ce qu'il peut faire :

Compatibilité complète avec l'écosystème d'extensions VS Code
Chat IA intégré et complétions en ligne
Indépendant du modèle
Open source : base de code entièrement auditable et auto-hébergeable

Limitations : projet plus récent, moins éprouvé que Continue ou Cline. Attendez-vous à des imperfections. Pas encore sur la Marketplace VS Code (installation manuelle requise).

Coût : gratuit.

5. Void editor

Qu'est-ce que c'est : un fork open source de VS Code qui ajoute des capacités natives d'IA sans avoir besoin d'extensions. Le projet vise à être le "Cursor open source."

Idéal pour : les développeurs qui veulent l'expérience utilisateur complète de Cursor sans l'abonnement et sont à l'aise avec un fork plutôt qu'une extension.

Configuration :

Téléchargez depuis voideditor.com
Ouvrez votre projet
Configurez votre modèle

Ce qu'il peut faire :

Chat et indexation de base de code natifs
Édition de diff en ligne
Système de points de contrôle (annuler des sessions d'édition IA complètes)
Support des modèles locaux via Ollama
Compatibilité complète avec les extensions VS Code

Limitations : les projets basés sur des forks sont en retard par rapport aux mises à jour de VS Code. Certaines extensions peuvent avoir des problèmes de compatibilité.

Coût : gratuit.

Tableau comparatif

Outil	Support IDE	Flexibilité du modèle	Mode Agent	Idéal pour	Coût
Continue.dev	VS Code, JetBrains	Complet (20+ fournisseurs)	Partiel	Édition assistée, contrôle du modèle équipe	Gratuit
Aider	Terminal	Complet	Complet (agent term)	Ingénieurs backend, automatisation CI/CD	Gratuit
Cline	VS Code	Complet (Claude, GPT, local)	Complet	Tâches multi-étapes autonomes dans VS Code	Gratuit
Modo	IDE basé sur VS Code	Complet	En développement	IDE axé sur l'IA sans abonnement	Gratuit
Void editor	Fork de VS Code	Complet	Partiel	UX similaire à Cursor, open source	Gratuit

Comment choisir le bon

Vous utilisez VS Code et souhaitez les fonctionnalités de chat de Cursor sans payer : commencez par Continue.dev. C'est le plus raffiné et il a la plus grande communauté.
Vous êtes un développeur backend qui travaille dans le terminal : Aider. Il est conçu spécifiquement pour ce workflow et s'intègre nativement à Git. Voir [internal: how-to-build-tiny-llm-from-scratch] si vous développez également des backends alimentés par l'IA.
Vous voulez un agent entièrement autonome capable d'exécuter des tâches multi-fichiers de bout en bout : Cline. C'est l'agent open source le plus performant et le plus proche du mode agent de Cursor.
Vous voulez un IDE IA dédié sans extensions : essayez Void editor. Surveillez Modo lorsqu'il mûrira.
Vous avez besoin d'une confidentialité totale du code (pas d'appels API externes) : n'importe lequel de ces outils avec Ollama comme backend de modèle. Qwen2.5-Coder-32B fonctionne bien sur une machine avec 24 Go+ de VRAM et produit un code de qualité production pour la plupart des tâches.
Vous évaluez pour une équipe : Continue.dev et Cline prennent tous deux en charge la configuration partagée via des fichiers de configuration versionnés, ce qui les rend plus faciles à standardiser au sein d'une équipe. Voir [internal: rest-api-best-practices] pour la mise en place de tests API cohérents avec votre configuration de codage.

Comment Apidog s'intègre aux workflows de codage IA

Les assistants de codage IA génèrent du code rapidement. C'est le but. Ce qu'ils ne font pas, c'est vérifier que les API que le code appelle fonctionnent réellement.

Lorsque Cline ou Continue.dev vous écrit un client REST, il peut sembler syntaxiquement correct tout en étant sémantiquement erroné. Chemins de points de terminaison incorrects, en-têtes d'authentification manquants, schéma JSON incorrect, gestion uniquement du cas de succès. Ces bugs ne font surface que lorsque vous exécutez le code contre un serveur en direct.

Les scénarios de test d'Apidog les détectent avant cela. Après qu'un assistant IA ait généré du code client API :

Importez le point de terminaison généré dans Apidog (collez l'URL + méthode, ou importez depuis la spécification OpenAPI du code s'il en génère une)
Créez un scénario de test qui enchaîne le chemin heureux : authentification, requête principale, assertion sur la structure de la réponse
Ajoutez des cas négatifs : jeton expiré, corps malformé, réponse de limite de débit
Utilisez Smart Mock pour simuler l'API tierce si vous n'avez pas d'environnement de staging

C'est ainsi que vous obtenez la rapidité de la génération de code IA sans déployer d'intégrations non testées. Les articles [internal: open-source-coding-assistants-2026] et [internal: claude-code] couvrent le côté agent ; Apidog couvre le côté vérification.

Exemple concret : vous demandez à Cline d'écrire un client API GitHub. Il génère une classe GitHubClient avec des méthodes pour créer des problèmes, lister des PR et récupérer les métadonnées du dépôt. Dans Apidog :

{
  "scenario": "Vérification du client API GitHub",
  "steps": [
    {
      "name": "Créer un problème",
      "method": "POST",
      "url": "https://api.github.com/repos/{owner}/{repo}/issues",
      "headers": {"Authorization": "Bearer {{token}}"},
      "body": {"title": "Problème de test", "body": "Créé par le scénario de test"},
      "assertions": [
        {"field": "status", "operator": "equals", "value": 201},
        {"field": "response.number", "operator": "exists"}
      ]
    },
    {
      "name": "Lister les problèmes (vérifier que le problème créé apparaît)",
      "method": "GET",
      "url": "https://api.github.com/repos/{owner}/{repo}/issues",
      "assertions": [
        {"field": "response[0].number", "operator": "equals", "value": "{{steps[0].response.number}}"}
      ]
    }
  ]
}

Cela prend cinq minutes à configurer et permet de détecter les erreurs de génération de code IA les plus courantes : mauvaise méthode HTTP, champs obligatoires manquants, pagination non gérée. Voir [internal: how-ai-agent-memory-works] pour tester les API d'agent avec état, ce qui ajoute une autre couche de complexité.

Conclusion

L'écosystème des assistants de codage open source est légitimement bon en 2026. Vous n'avez pas besoin d'un abonnement Cursor pour obtenir du codage agentique, un chat conscient de la base de code et des modifications multi-fichiers. Continue.dev, Aider et Cline couvrent chacun des workflows différents, et Modo/Void méritent d'être surveillés.

La pièce manquante est le test. Le code généré par l'IA est rapide à écrire et facile à mal faire. Associez votre assistant de codage open source à Apidog pour vérifier les intégrations d'API qu'il produit.

FAQ

Continue.dev est-il aussi bon que Cursor ?

Pour le chat et les modifications en ligne, c'est proche. Pour les tâches d'agent autonomes (écrire une fonctionnalité complète de bout en bout sans approbation), le mode agent de Cursor est toujours en avance. L'écart se réduit si vous configurez Continue.dev avec Claude 3.5 Sonnet ou GPT-4o.

Puis-je utiliser les assistants de codage open source uniquement avec des modèles locaux ?

Oui. Les cinq outils de cet article prennent en charge Ollama, ce qui vous permet d'exécuter des modèles comme Qwen2.5-Coder, DeepSeek-Coder-V2 ou Code Llama localement. La qualité du code avec les modèles locaux est inférieure à celle des modèles de pointe pour les tâches complexes, mais suffisante pour le code boilerplate et le refactoring.

Comment choisir un modèle pour les assistants de codage open source ?

Claude 3.5 Sonnet gère mieux les tâches complexes et multi-étapes. GPT-4o est fort pour la génération de code et a le meilleur support d'appel de fonctions. DeepSeek-Coder-V2 est le modèle open-weight le plus puissant pour les tâches de code et s'exécute localement. Commencez avec Claude ou GPT-4o si le coût n'est pas un problème ; DeepSeek si vous avez besoin de confidentialité ou de volume.

Aider est-il sûr à utiliser en mode --yes ?

Utilisez-le avec prudence. Le mode --yes approuve automatiquement chaque modification de fichier et chaque commit. Exécutez-le sur une branche, jamais sur main, et examinez le diff Git avant de fusionner. Il est utile pour les tâches automatisées en CI, mais pas pour le développement interactif où vous souhaitez examiner les modifications.

Qu'est-ce que Kiro ? Le post HN le mentionnait aux côtés de Cursor et Windsurf.

Kiro est un IDE IA d'AWS, annoncé en 2025. Il est basé sur VS Code, comme Cursor, mais avec une intégration AWS étroite. Il n'est pas open source. Le README GitHub de Modo le nomme spécifiquement comme l'un des outils qu'il vise à remplacer.

Les équipes peuvent-elles partager la configuration de ces outils ?

Oui. Continue.dev lit à partir de .continue/config.json à la racine de votre dépôt, qui peut être commité au contrôle de version. Cline stocke les paramètres dans settings.json de VS Code. Aider lit à partir de .aider.conf.yml. Les trois peuvent être standardisés au sein d'une équipe avec un fichier de configuration partagé.

Ces outils fonctionnent-ils hors ligne ?

Avec les modèles locaux via Ollama : oui, entièrement hors ligne. Avec les modèles basés sur API (Claude, GPT-4o) : non, ils nécessitent une connexion Internet. Void editor et Modo peuvent être configurés pour une utilisation hors ligne avec des modèles locaux.

Fonctionnement de la mémoire des agents IA et test via API

Antoine Laurent — Tue, 07 Apr 2026 08:09:11 +0000

TL;DR

Les agents IA échouent non pas par manque d'intelligence, mais parce qu'ils oublient. Comprendre les quatre types de mémoire des agents, comment elles sont stockées et comment elles affectent le comportement de l'API vous permet de construire des agents plus fiables et de détecter les bugs avant qu'ils n'atteignent la production.

Essayez Apidog dès aujourd'hui

Introduction

Voici le vilain secret de la plupart des échecs des agents IA : le modèle va bien. C'est la couche de mémoire qui est défectueuse.

Un agent qui ne se souvient pas de ce qui s'est passé il y a trois tours, qui perd le contexte utilisateur entre les sessions, ou qui se contredit en pleine tâche n'est pas en train d'halluciner à cause de la qualité du modèle. Il échoue parce que l'architecture de la mémoire n'a pas été conçue avec soin ou n'a pas été testée du tout.

Hippo, un système de mémoire d'agent open-source qui a récemment fait le buzz, adopte une approche biologiquement inspirée : il modélise la mémoire à court terme, à long terme et épisodique séparément, de la même manière que la mémoire humaine fonctionne. Ce projet a mis en lumière une lacune réelle : la plupart des développeurs construisent la mémoire des agents comme une réflexion après coup et ne découvrent qu'elle est défectueuse qu'en production.

💡 Les scénarios de test d'Apidog vous permettent de tester des conversations d'agents avec état et à plusieurs tours avant leur mise en ligne. Vous pouvez vérifier que l'état de la session est transféré entre les appels d'API, affirmer la structure du contexte et simuler des défaillances de mémoire avec Smart Mock. Cette couche de test est le sujet de la seconde moitié de cet article. Pour l'instant, commençons par ce qui se passe réellement à l'intérieur de la mémoire de l'agent. Consultez [internal: api-testing-tutorial] pour une introduction à l'approche de test plus large.

Qu'est-ce que la mémoire d'un agent IA ?

La mémoire d'agent est tout mécanisme permettant à un système d'IA d'accéder ou de conserver des informations au-delà de l'entrée actuelle. Sans elle, chaque appel d'API est sans état : le modèle reçoit une invite, renvoie une réponse et ne se souvient de rien.

Quatre types de mémoire distincts servent des objectifs différents.

Les quatre types de mémoire d'agent

Mémoire de travail

La mémoire de travail est le contexte actif de l'agent : tout ce qui se trouve dans l'invite actuelle. Pour la plupart des agents basés sur des LLM, il s'agit de la fenêtre contextuelle. GPT-4o a une fenêtre contextuelle de 128K jetons. Claude 3.5 Sonnet supporte 200K. Gemini 1.5 Pro supporte 1M.

La mémoire de travail est rapide et précise, mais coûteuse (vous payez par jeton) et limitée. Une fois la limite atteinte, le contexte le plus ancien est discrètement supprimé. C'est la source la plus courante de bugs d'agent dans les tâches de longue durée.

Mémoire épisodique

La mémoire épisodique stocke ce qui s'est passé : un journal des interactions, des décisions et des observations passées. Considérez-la comme le journal de l'agent.

En pratique, il s'agit généralement d'une base de données vectorielle (Chroma, Pinecone, Qdrant) ou d'un journal d'événements structuré. L'agent récupère les épisodes passés pertinents via une recherche sémantique avant de générer une réponse. L'approche d'Hippo stocke les séquences d'interaction avec des horodatages et des poids de dégradation, de sorte que les interactions récentes bénéficient d'une priorité de récupération plus élevée.

Mémoire sémantique

La mémoire sémantique stocke ce que l'agent sait : des faits, des connaissances spécifiques au domaine, les préférences de l'utilisateur et des connaissances stables sur le monde. Contrairement à la mémoire épisodique, elle n'est pas ordonnée dans le temps.

Celle-ci peut être préchargée (une invite système avec des données de profil utilisateur), construite dynamiquement (faits extraits de conversations passées et stockés dans un graphe de connaissances) ou obtenue de sources externes (RAG contre un magasin de documents).

Mémoire procédurale

La mémoire procédurale stocke comment faire les choses : des séquences d'actions, des modèles d'utilisation d'outils et des compétences que l'agent a apprises. C'est la plus difficile à construire et elle est souvent ignorée dans les systèmes de production.

En pratique, elle apparaît sous forme d'exemples "few-shot" intégrés dans l'invite système, ou comme une bibliothèque de plans d'action stockés que l'agent peut récupérer et adapter.

Comment la mémoire est stockée dans les systèmes réels

Les quatre types correspondent rarement proprement à quatre magasins distincts. Les configurations réelles ressemblent davantage à ceci :

Fenêtre contextuelle (de travail) : tout ce qui se trouve dans l'invite active. Gérée par le framework de l'agent. Expire à la fin de la conversation.
Magasin de vecteurs externe (épisodique + sémantique) : Chroma, Pinecone ou Qdrant stocke les embeddings des interactions passées et des blocs de connaissances. L'agent interroge cela à chaque tour et injecte les blocs pertinents dans l'invite.
Base de données structurée (sémantique + procédurale) : PostgreSQL ou SQLite pour les préférences utilisateur, l'état du compte ou les modèles d'actions appris. Interrogée via des appels d'outils.
Cache en mémoire (débordement de travail) : Redis ou un simple dict pour un accès rapide au contexte récent qui n'a pas besoin de recherche d'embedding.

Hippo modélise spécifiquement son système de mémoire à trois niveaux avec une logique de transfert explicite : les entrées de mémoire de travail qui n'ont pas été accédées récemment sont consolidées en mémoire épisodique, qui est finalement résumée en mémoire sémantique. Cela reflète la façon dont la consolidation de la mémoire humaine fonctionne pendant le sommeil (le projet dispose même d'une commande "sleep" pour déclencher la consolidation).

Comment la mémoire d'agent affecte le comportement de l'API

Si vous construisez ou consommez une API d'agent, la mémoire façonne directement l'apparence de vos appels d'API et ce qui peut mal tourner.

ID de session : la plupart des API d'agents utilisent un ID de session ou de thread pour corréler la mémoire entre les appels. L'API OpenAI Assistants utilise thread_id. Un ID de thread abandonné ou réutilisé entraîne la perte de contexte par l'agent ou le mélange des sessions de deux utilisateurs.
Taille du contexte dans les charges utiles des requêtes : les agents qui injectent de la mémoire dans les invites produisent des corps de requête plus volumineux au fil du temps. Une conversation d'agent qui commence à 2 Ko peut atteindre 40 Ko après 20 tours. Si votre client HTTP a une limite de taille de charge utile, les requêtes échouent silencieusement.
Latence de récupération : les recherches dans les magasins de vecteurs ajoutent 50 à 200 ms par tour. Si vous effectuez des assertions sur le temps de réponse de l'API, la récupération de la mémoire est un véritable contributeur.
État incohérent après les échecs : si l'appel d'outil d'un agent échoue en cours de tâche, le journal épisodique peut enregistrer une action partielle. Le tour suivant démarre à partir d'un état corrompu. Les bons agents sauvegardent l'état avant et après l'utilisation d'un outil.

Comment tester la mémoire d'un agent via API avec Apidog

Testez les API d'agents avec état nécessite plus qu'une simple assertion de requête unique. Vous devez vérifier que le contexte est transféré sur plusieurs appels, que les réponses basées sur la mémoire changent comme prévu, et que le système se dégrade gracieusement lorsque la mémoire est indisponible.

Les scénarios de test d'Apidog gèrent précisément cela. Voici comment en configurer un pour une API d'agent.

Test 1 : Transfert de contexte

Créez un scénario avec trois étapes séquentielles :

POST /agent/chat avec un message introduisant un fait ("Mon projet utilise PostgreSQL 16")
POST /agent/chat avec un suivi qui nécessite de rappeler ce fait ("Pour quelle base de données devrais-je optimiser ?")
Affirmez sur la réponse de l'étape 2 : response.message.content devrait contenir "PostgreSQL"

Si la couche de mémoire de l'agent fonctionne, l'étape 2 récupère le fait de la mémoire épisodique ou sémantique et l'utilise dans la réponse. Sinon, vous obtenez une réponse générique.

Test 2 : Isolation de session

Exécutez la même séquence en deux étapes deux fois avec des valeurs de session_id différentes. Affirmez que la réponse de la deuxième session ne contient aucun contexte de la première session. Cela détecte les bugs de mémoire partagée, fréquents dans les déploiements d'agents multi-locataires.

Test 3 : Dégradation en cas de défaillance de la mémoire

Utilisez Smart Mock d'Apidog pour simuler une défaillance du backend de mémoire. Configurez le mock pour qu'il renvoie un 503 sur le point de terminaison de recherche du magasin de vecteurs. Exécutez ensuite votre conversation d'agent et affirmez que :

L'agent répond sans planter
La réponse inclut une solution de repli gracieuse ("Je n'ai pas assez de contexte pour répondre à cela")
La session peut reprendre une fois le mock supprimé

Test 4 : Débordement de la fenêtre contextuelle

Envoyez plus de 30 messages rapides en séquence pour pousser la mémoire de travail au-delà de la limite de contexte. Affirmez que :

L'agent ne génère pas d'erreur context_length_exceeded (il devrait tronquer gracieusement)
La réponse au 30e tour répond toujours correctement en utilisant la récupération épisodique
Le nombre de jetons dans response.usage reste dans la plage attendue

Vous pouvez exécuter ces quatre tests en un seul scénario de test dans Apidog, en les chaînant séquentiellement avec des variables partagées pour les ID de session et les données de réponse. Consultez [internal: how-to-build-tiny-llm-from-scratch] pour des informations sur la raison pour laquelle les fenêtres contextuelles fonctionnent comme elles le font au niveau du modèle.

Modes de défaillance courants de la mémoire

Troncation silencieuse du contexte : la fenêtre contextuelle se remplit et les messages plus anciens disparaissent sans avertissement. L'agent répond sur la base d'un historique incomplet. Détectez cela en affirmant sur response.usage.prompt_tokens et en vérifiant qu'il reste en dessous de la limite de contexte de votre modèle.
Fuite de session : les sessions de deux utilisateurs partagent un espace de noms de mémoire. Détectez cela avec des tests d'isolation de session.
Mémoire sémantique obsolète : des connaissances stockées il y a des semaines contredisent des faits actuels. L'agent donne avec confiance des informations erronées. Détectez cela en incluant une assertion de "date actuelle" dans votre test : si l'agent cite un prix ou un numéro de version, affirmez qu'il correspond à la valeur que vous avez chargée dans le contexte de test.
Dérive d'embedding : les magasins de vecteurs construits avec un modèle d'embedding se cassent lorsque vous passez à un autre. Tous les documents récupérés deviennent sémantiquement erronés. Non directement testable via l'API, mais vous pouvez ajouter une assertion qui vérifie si le contexte récupéré est sémantiquement lié à la requête.
Injection de mémoire / injection d'invite : une entrée utilisateur malveillante qui manipule ce qui est stocké et récupéré. Incluez des entrées adverses dans votre suite de tests : stockez une "préférence utilisateur" qui contient une surcharge d'invite système et vérifiez que l'agent l'ignore. Consultez [internal: rest-api-best-practices] pour des conseils plus larges sur les tests de sécurité API.

Conclusion

La mémoire d'agent est la différence entre un assistant qui semble intelligent et un qui semble amnésique. Les quatre types, de travail, épisodique, sémantique et procédurale, ont chacun un rôle distinct. Comprendre comment elles sont stockées et récupérées dans les systèmes réels vous indique exactement où les bugs peuvent se cacher et ce qu'il faut affirmer dans vos tests d'API.

Des outils comme Hippo montrent que le domaine s'oriente vers une architecture de mémoire basée sur des principes. Quel que soit le système de mémoire sur lequel vous construisez, les scénarios de test d'Apidog vous offrent la couche de test pour vérifier qu'il se comporte comme vous l'attendez, en particulier les cas de défaillance qui n'apparaissent qu'à grande échelle.

FAQ

Quelle est la manière la plus simple d'ajouter de la mémoire à un agent ?

L'approche la plus simple est une fenêtre glissante sur l'historique des conversations : conserver les N derniers tours dans l'invite. Ce n'est pas une mémoire épisodique, mais cela fonctionne pour des tâches courtes. Pour les agents de plus longue durée, ajoutez un magasin de vecteurs et une récupération sémantique.

Comment l'API OpenAI Assistants gère-t-elle la mémoire ?

L'API Assistants gère un objet thread qui stocke l'historique de la conversation côté serveur. Vous pouvez également attacher des outils de recherche de fichiers et d'interprétation de code qui donnent à l'agent accès à des connaissances externes. La gestion de la mémoire est abstraite, ce qui est pratique mais rend le débogage plus difficile.

Quelle est la meilleure base de données vectorielles pour la mémoire d'agent ?

Pour le développement local : Chroma (aucune infrastructure nécessaire). Pour la production : Qdrant ou Pinecone selon que vous ayez besoin d'une solution auto-hébergée ou gérée. La bibliothèque Hippo prend en charge les backends de stockage enfichables. Consultez [internal: claude-code] pour voir comment Claude Code utilise sa propre couche de mémoire.

Comment empêcher les agents d'halluciner sur des interactions passées ?

Stockez les journaux d'interaction dans un format structuré avec des métadonnées (horodatage, confiance, source). Lors de la récupération du contexte passé, incluez les métadonnées dans l'invite : "Selon notre conversation du [date], vous avez mentionné X." La citation explicite réduit les hallucinations confiantes.

Puis-je tester la mémoire d'un agent sans agent en cours d'exécution ?

Oui. Utilisez Smart Mock d'Apidog pour simuler les réponses de l'API de l'agent, y compris celles basées sur la mémoire. Définissez des réponses simulées qui changent en fonction de l'ID de session ou du contenu du corps de la requête. Cela vous permet de tester la gestion du comportement de la mémoire par votre couche frontend ou d'intégration sans avoir d'agent en direct.

Combien coûte le stockage vectoriel en production ?

Le niveau gratuit de Pinecone prend en charge 1 index avec 100K vecteurs. À grande échelle, Pinecone facture environ 0,096 $/heure pour un pod p1.x1 (1M de vecteurs à 768 dimensions). Qdrant auto-hébergé est gratuit. Pour la plupart des agents, le coût le plus important est la génération d'embeddings, pas le stockage. Consultez [internal: what-is-mcp-server] pour savoir comment les intégrations de serveurs MCP interagissent avec les systèmes de mémoire d'agent.

Quelle est la différence entre RAG et la mémoire d'agent ?

RAG (génération augmentée par récupération) récupère des documents pertinents au moment de la requête à partir d'une base de connaissances fixe. La mémoire d'agent est dynamique : elle grandit et change au fur et à mesure que l'agent interagit. Un système RAG répond "que disent les documents à propos de X ?" Un système de mémoire d'agent répond "que sais-je de cet utilisateur et qu'ai-je fait avec lui ?"

Comment Créer un LLM de Zéro : Guide et Enseignements

Antoine Laurent — Tue, 07 Apr 2026 04:36:53 +0000

En bref

Construire un modèle de langage minimal à partir de zéro prend moins de 300 lignes de Python. Le processus révèle exactement comment fonctionnent la tokenisation, l'attention et l'inférence, ce qui fait de vous un bien meilleur consommateur d'API lorsque vous intégrez des LLM de production dans vos applications.

Essayez Apidog dès aujourd'hui

Introduction

La plupart des développeurs traitent les modèles de langage comme des boîtes noires. Vous envoyez du texte, des jetons en sortent, et quelque part entre les deux, la magie opère. Ce modèle mental fonctionne bien jusqu'à ce que vous ayez besoin de déboguer une intégration d'API cassée, d'ajuster les paramètres d'échantillonnage, ou de comprendre pourquoi votre modèle continue d'halluciner des données structurées.

GuppyLM, un projet qui a récemment atteint la première page de HackerNews avec 842 points, rend les mécanismes internes visibles. C'est un transformeur de 8,7 millions de paramètres écrit à partir de zéro en Python. Il s'entraîne en moins d'une heure sur un GPU grand public. Le code tient dans un seul fichier. L'objectif n'est pas de concurrencer GPT-4 ; c'est de démystifier ce que font réellement les LLM.

Cet article explique comment construire un petit LLM, ce que fait chaque composant et ce que la compréhension de ces mécanismes internes vous apprend lorsque vous travaillez professionnellement avec des API d'IA.

💡
Si vous testez des intégrations d'API d'IA, les Scénarios de Test d'Apidog vous permettent de vérifier les réponses en streaming, d'affirmer la structure des jetons et de simuler des complétions de cas limites sans gaspiller vos crédits de production. Plus à ce sujet plus tard.

Qu'est-ce qui rend un modèle de langage "minuscule" ?

Un LLM de production comme GPT-4 possède des centaines de milliards de paramètres. Un LLM "minuscule" se situe dans la plage de 1M à 25M de paramètres. Des projets comme GuppyLM (8,7M), nanoGPT de Karpathy (124M) et MicroLM (1-2M) entrent tous dans cette catégorie.

Les LLM minuscules permettent de :

S'entraîner sur un ordinateur portable ou Google Colab
Tenir entièrement en mémoire CPU
Être inspectés, modifiés et débogués au niveau des poids

Limites :

Incapacité à gérer des raisonnements complexes
Génération peu fiable de texte long et cohérent
Moins de profondeur factuelle que les modèles de production

L'intérêt principal : comprendre le fonctionnement interne des LLM.

Composants clés : comment fonctionne réellement un LLM

Avant d'écrire du code, il faut comprendre les quatre principales parties.

Tokeniseur

Le tokeniseur convertit le texte brut en ID entiers. Par exemple, "Bonjour, le monde !" devient quelque chose comme [15496, 11, 995, 0]. Chaque entier correspond à une unité de sous-mot d'un vocabulaire fixe.

Impact sur les API : le nombre de jetons impacte la latence et le coût. Comprendre la découpe du texte par le tokeniseur vous aide à rédiger des prompts qui rentrent dans la fenêtre de contexte et à éviter la troncature.

GuppyLM utilise un tokeniseur caractère. Les modèles de production (GPT-4, etc.) utilisent le BPE (byte-pair encoding) avec des vocabulaires de 50K-100K jetons.

Couche d'intégration (embedding)

La couche d'intégration convertit les ID de jetons en vecteurs denses (par exemple, 384 dimensions dans GuppyLM). Ces vecteurs portent un sens sémantique : les jetons similaires sont proches dans l'espace vectoriel.

Des intégrations de position sont ajoutées pour que le modèle connaisse l'ordre des jetons.

Blocs Transformeur

Le cœur du calcul. Chaque bloc a deux parties :

Auto-attention : chaque jeton examine tous les autres jetons de la séquence pour décider lesquels sont importants pour prédire le jeton suivant. GuppyLM utilise 6 têtes d'attention sur 6 couches.

Réseau feed-forward : un MLP à deux couches appliqué à chaque jeton après l'attention. GuppyLM utilise une activation ReLU (plus simple que le SwiGLU des architectures récentes).

Tête de sortie

Après le dernier bloc de transformateur, une couche linéaire projette la représentation de chaque jeton vers un vecteur de taille égale au vocabulaire. On applique softmax pour obtenir des probabilités, on choisit le jeton suivant (ou on échantillonne), et on recommence.

Construire un LLM minimal en Python

Voici un LLM minimal fonctionnel, inspiré de GuppyLM, en PyTorch standard :

import torch
import torch.nn as nn
import torch.nn.functional as F

# Hyperparamètres
VOCAB_SIZE = 256     # niveau caractère : un emplacement par caractère ASCII
D_MODEL = 128        # dimension d'intégration (embedding)
N_HEADS = 4          # têtes d'attention
N_LAYERS = 3         # blocs transformeur
SEQ_LEN = 64         # fenêtre de contexte
DROPOUT = 0.1

class SelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.head_dim = d_model // n_heads
        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.proj = nn.Linear(d_model, d_model, bias=False)
        self.dropout = nn.Dropout(DROPOUT)

    def forward(self, x):
        B, T, C = x.shape
        qkv = self.qkv(x).reshape(B, T, 3, self.n_heads, self.head_dim)
        q, k, v = qkv.unbind(dim=2)
        q = q.transpose(1, 2)
        k = k.transpose(1, 2)
        v = v.transpose(1, 2)
        # Masque causal : chaque jeton ne peut faire attention qu'aux jetons précédents
        scale = self.head_dim ** -0.5
        attn = (q @ k.transpose(-2, -1)) * scale
        mask = torch.triu(torch.ones(T, T, device=x.device), diagonal=1).bool()
        attn = attn.masked_fill(mask, float('-inf'))
        attn = F.softmax(attn, dim=-1)
        attn = self.dropout(attn)
        out = (attn @ v).transpose(1, 2).reshape(B, T, C)
        return self.proj(out)

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.attn = SelfAttention(d_model, n_heads)
        self.ff = nn.Sequential(
            nn.Linear(d_model, 4 * d_model),
            nn.ReLU(),
            nn.Linear(4 * d_model, d_model),
            nn.Dropout(DROPOUT),
        )
        self.ln1 = nn.LayerNorm(d_model)
        self.ln2 = nn.LayerNorm(d_model)

    def forward(self, x):
        x = x + self.attn(self.ln1(x))
        x = x + self.ff(self.ln2(x))
        return x

class TinyLLM(nn.Module):
    def __init__(self):
        super().__init__()
        self.embed = nn.Embedding(VOCAB_SIZE, D_MODEL)
        self.pos_embed = nn.Embedding(SEQ_LEN, D_MODEL)
        self.blocks = nn.ModuleList([
            TransformerBlock(D_MODEL, N_HEADS) for _ in range(N_LAYERS)
        ])
        self.ln_f = nn.LayerNorm(D_MODEL)
        self.head = nn.Linear(D_MODEL, VOCAB_SIZE, bias=False)

    def forward(self, idx):
        B, T = idx.shape
        tok_emb = self.embed(idx)
        pos = torch.arange(T, device=idx.device)
        pos_emb = self.pos_embed(pos)
        x = tok_emb + pos_emb
        for block in self.blocks:
            x = block(x)
        x = self.ln_f(x)
        logits = self.head(x)
        return logits

# Initialiser et compter les paramètres
model = TinyLLM()
total_params = sum(p.numel() for p in model.parameters())
print(f"Taille du modèle : {total_params:,} paramètres")  # ~1.2M

Boucle d'entraînement

import torch.optim as optim

def train(model, data, epochs=100, lr=3e-4):
    optimizer = optim.AdamW(model.parameters(), lr=lr)
    model.train()
    for epoch in range(epochs):
        # data: tenseur d'ID de jetons, forme [batch, seq_len+1]
        x = data[:, :-1]   # entrée : tous les jetons sauf le dernier
        y = data[:, 1:]    # cible : tous les jetons décalés de 1
        logits = model(x)
        loss = F.cross_entropy(logits.reshape(-1, VOCAB_SIZE), y.reshape(-1))
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if epoch % 10 == 0:
            print(f"Époque {epoch}, perte : {loss.item():.4f}")

Inférence (génération de texte)

@torch.no_grad()
def generate(model, prompt_ids, max_new_tokens=50, temperature=1.0, top_k=10):
    model.eval()
    ids = torch.tensor([prompt_ids])
    for _ in range(max_new_tokens):
        idx_cond = ids[:, -SEQ_LEN:]  # rogner à la fenêtre de contexte
        logits = model(idx_cond)
        logits = logits[:, -1, :] / temperature  # dernier jeton seulement
        # échantillonnage top-k
        v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
        logits[logits < v[:, [-1]]] = float('-inf')
        probs = F.softmax(logits, dim=-1)
        next_id = torch.multinomial(probs, num_samples=1)
        ids = torch.cat([ids, next_id], dim=1)
    return ids[0].tolist()

Ce que cela vous apprend sur le comportement des API d'IA

Construire un LLM vous rend plus efficace avec les API d'IA. Voici les enseignements essentiels :

La température et l'échantillonnage sont des mécaniques

La température divise les logits avant softmax.

Température élevée = plus aléatoire
Température basse = plus déterministe

Avec temperature=0.0, la plupart des API planchent la valeur pour éviter les sorties dégénérées. Si vos résultats sont inconsistants à température zéro, ce n'est pas un bug.

Les fenêtres de contexte sont des limites strictes

La ligne idx_cond = ids[:, -SEQ_LEN:] dans l'inférence montre la réalité : les jetons hors contexte sont supprimés. Votre API n'a plus l'historique complet au bout d'un moment. Voir [internal: how-ai-agent-memory-works] pour plus de détails.

Le streaming de jetons = étapes d'inférence visibles

Les API de streaming exécutent la boucle d'inférence et transmettent chaque jeton au flux en temps réel. Si le flux est interrompu, il faut recommencer : impossible de reprendre une génération coupée.

Les logits expliquent la difficulté de la sortie structurée

À chaque étape, le modèle attribue une probabilité à chaque jeton. Générer un JSON valide exige que chaque jeton correct soit sélectionné à chaque position. Des bibliothèques comme Outlines et Guidance contraignent la distribution pour garantir la grammaire. Les modes de "sortie structurée" des API font exactement cela en interne.

Comment tester les intégrations d'API d'IA avec Apidog

Avec une compréhension claire de l'inférence LLM, vous pouvez écrire de meilleurs tests d'API.

Les scénarios de test d'Apidog permettent de chaîner les appels API et d'affirmer la structure des réponses IA.

Exemple pour tester une API de chat en streaming :

Créez un scénario de test dans Apidog avec le point de terminaison /v1/chat/completions
Définissez des assertions sur la réponse : response.choices[0].finish_reason == "stop", response.usage.total_tokens < 4096
Ajoutez une étape pour envoyer la réponse comme contexte au tour suivant (multi-tours)
Utilisez Smart Mock d'Apidog pour simuler des cas d'erreur : finish_reason: "length" (sortie tronquée), finish_reason: "content_filter", ou un timeout réseau en cours de flux

Cela permet de tester les intégrations IA sans consommer de crédits API à chaque CI. Consultez [internal: api-testing-tutorial] pour un aperçu plus large des stratégies de test API.

Test des assertions de nombre de jetons

{
  "assertions": [
    {
      "field": "response.usage.completion_tokens",
      "operator": "less_than",
      "value": 512
    },
    {
      "field": "response.choices[0].finish_reason",
      "operator": "equals",
      "value": "stop"
    },
    {
      "field": "response.choices[0].message.content",
      "operator": "not_empty"
    }
  ]
}

Exécutez ce scénario sur plusieurs modèles (GPT-4o, Claude 3.5 Sonnet, Gemini 1.5 Pro) pour détecter les différences de schéma avant la mise en production.

Avancé : Quantification et optimisation de l'inférence

Lorsque votre LLM minimal fonctionne, deux optimisations sont à connaître :

Quantification

Les poids sont en float32 par défaut. La quantification réduit à INT8 ou INT4, divisant la mémoire utilisée par 4 à 8 avec une perte de précision modérée.

# Quantification INT8 dynamique dans PyTorch
import torch.quantization
quantized_model = torch.quantization.quantize_dynamic(
    model, {nn.Linear}, dtype=torch.qint8
)

Les API de production servent des modèles quantifiés. Une différence de qualité entre versions de modèle peut venir de la quantification.

Cache KV

Dans la boucle d'inférence ci-dessus, l'attention est recalculée sur toute la séquence à chaque étape. En production, les clés/valeurs des jetons précédents sont mises en cache (cache KV) : chaque nouveau jeton ne nécessite que le calcul d'attention du dernier token. C'est pourquoi le premier jeton d'une réponse en streaming est plus lent que les suivants.

Petit LLM vs. API de production : quand utiliser lequel

Cas d'utilisation	Petit LLM	API de production
Apprendre le fonctionnement interne	Idéal	Exagéré
Prototypage d'une nouvelle application	Qualité insuffisante	Idéal
Données privées/sensibles	Bonne option	Dépend du fournisseur
Déploiement hors ligne/en périphérie	Viable	Non possible
Coût-sensible, gros volume	Possible avec compromis	Coûteux à grande échelle
Raisonnement complexe requis	Non viable	Requis

La plupart du temps : utilisez l'API de production, mais exécutez un petit LLM pour comprendre ce qui se passe sous le capot. Les deux approches sont complémentaires. Consultez [internal: open-source-coding-assistants-2026] pour explorer les assistants open source "apportez votre propre modèle".

Conclusion

Construire un petit LLM à partir de zéro prend un week-end. Ce n'est pas un système de production, mais vous comprendrez vraiment comment fonctionnent tous les LLM, de GuppyLM à GPT-4o. Cette compréhension est précieuse pour déboguer, ajuster les paramètres d'échantillonnage, ou écrire des assertions pour vos tests d'API IA.

GuppyLM est un excellent point de départ : clonez-le, entraînez-le sur un dataset textuel, et plongez dans la boucle d'inférence. Ensuite, vos intégrations d'API de production ne vous paraîtront plus jamais opaques.

Testez vos intégrations d'API d'IA avec les Scénarios de Test d'Apidog pour la même rigueur que pour tout autre backend.

FAQ

Combien de paramètres un "petit" LLM a-t-il besoin pour générer du texte cohérent ?

Environ 10M-50M de paramètres avec un jeu de données d'entraînement décent permettent des phrases localement cohérentes. En dessous de 1M, c'est souvent du charabia. GuppyLM (8,7M) fonctionne pour des conversations courtes sur son domaine d'entraînement (60 sujets).

Puis-je exécuter un petit LLM sans GPU ?

Oui. Les modèles <100M de paramètres fonctionnent sur CPU, plus lentement. Le modèle ci-dessus (1,2M) génère des jetons en millisecondes sur un CPU d'ordinateur portable.

Quel jeu de données utiliser pour l'entraînement ?

Les modèles caractère fonctionnent bien avec le Projet Gutenberg, des sous-ensembles Wikipédia ou tout corpus texte brut. GuppyLM utilise un dataset de conversations (60K entrées, HuggingFace : arman-bd/guppylm-60k-generic). Pour du code, utilisez The Stack ou CodeParrot.

Différence entre température et top-k ?

La température module la distribution des logits (aléatoire globale). Top-k restreint l'échantillonnage aux k jetons les plus probables avant d'appliquer la température. On applique d'abord top-k, puis la température.

Pourquoi mon LLM se répète-t-il parfois ?

La répétition vient du modèle qui donne une forte proba aux jetons récemment générés. Les API de production appliquent des pénalités de répétition (repetition_penalty=1.1).

Temps d'entraînement d'un petit LLM ?

Le modèle ci-dessus s'entraîne en moins de 2h sur un GPU (RTX 3060 ou équivalent). GuppyLM : similaire dans Colab. Les modèles plus gros (>100M) nécessitent multi-GPU et plusieurs jours.

Passer à un endpoint API ?

Exportez au format GGUF via llama.cpp, puis servez-le avec llama-server pour un endpoint API compatible OpenAI local. Pointez Apidog dessus pour les tests ([internal: rest-api-best-practices]).

Comment les LLM de production gèrent-ils un contexte plus long que leur fenêtre ?

Techniques : RoPE (Rotary Position Embedding) avec mise à l'échelle, attention glissante, RAG. L'architecture de base reste un transformeur ; ce sont des modifications sur l'encodage de position et la fenêtre d'attention.

Images, vidéos, et liens originaux conservés.

Comment Utiliser l'API Seedance 2.0 en 2026

Antoine Laurent — Sat, 04 Apr 2026 13:07:24 +0000

En bref

L'API Seedance 2.0 a été lancée le 2 avril 2026 via Volcengine Ark. Vous soumettez une tâche de génération de vidéo avec une requête POST, puis interrogez un point de terminaison GET jusqu'à ce que le statut atteigne "succeeded" (réussi). L'API prend en charge le texte-vers-vidéo, l'image-vers-vidéo, le contrôle de la première et de la dernière image, les références multimodales et la génération audio native. Une vidéo de 1080p de 5 secondes coûte environ 0,93 $. Téléchargez la vidéo dans les 24 heures. L'URL expire après cela.

Essayez Apidog dès aujourd'hui

Hypereal AI

Essayer Hypereal AI

Introduction

Le 2 avril 2026, la plateforme Volcengine Ark de ByteDance a publié l'API officielle Seedance 2.0. Avant cette date, la génération de vidéos Seedance 2.0 se faisait uniquement via la console web. Les tutoriels web existants concernaient l'interface utilisateur. Ce guide détaille l'usage direct de l'API pour l'intégration développeur.

💡 L'API applique un modèle de tâche asynchrone : POST pour créer, ID de tâche reçu, puis interrogation GET jusqu'à complétion. Testez ce workflow de bout en bout avant la mise en production. Les scénarios de test Apidog permettent d’enchaîner la soumission POST, d’extraire l’ID de tâche, de boucler l’interrogation GET et de vérifier la présence d’une URL vidéo valide. Utilisez Apidog pour suivre les étapes pratiques décrites plus bas.

Cet article couvre chaque type d'entrée, le calcul du coût à partir du nombre de jetons et la gestion des erreurs courantes.

Qu'est-ce que Seedance 2.0 ?

Seedance 2.0 est un modèle de génération vidéo de ByteDance fonctionnant sur Volcengine Ark avec les IDs :

doubao-seedance-2-0-260128 (standard)
doubao-seedance-2-0-fast-260128 (rapide, qualité inférieure)

Nouveautés par rapport à la version 1.5 :

Contrôle de la première et dernière image
Références multimodales (images, clips vidéo, fichiers audio dans une même requête)
Génération audio native (dialogues, SFX, musique, ambiance)
Synchronisation labiale multilingue (8+ langues)
Contrôle du mouvement caméra par prompts
Jusqu’à 15 secondes, résolution jusqu’à 2K

Production en 24 ips, ratios de 1:1 à 21:9. Choisissez la résolution lors de la requête.

Ce qui a changé : guide vs API officielle

Les anciens guides Seedance 2.0 (par exemple ce guide de février 2026) expliquaient la console web, sans API. Maintenant, vous pouvez :

Appeler l’API depuis n’importe quel langage
Automatiser la génération vidéo
Intégrer Seedance dans vos produits

Ce guide est la référence pour tout usage développeur.

Prérequis

Créez un compte Volcengine sur volcengine.com
Accédez à la console Ark :

   https://console.volcengine.com/ark/region:ark+cn-beijing/apikey

Générez une clé API et exportez-la :

   export ARK_API_KEY="your-api-key-here"

Utilisez la clé dans l’en-tête Bearer :

   Authorization: Bearer YOUR_ARK_API_KEY

Les nouveaux comptes reçoivent des crédits gratuits (environ 8 générations complètes de 15s en 1080p).

Texte-vers-vidéo : votre première requête

L’URL de base API :

https://ark.cn-beijing.volces.com/api/v3

Soumission POST vers /v1/contents/generations/tasks.

Exemple cURL

curl -X POST "https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ARK_API_KEY" \
  -d '{
    "model": "doubao-seedance-2-0-260128",
    "content": [
      {
        "type": "text",
        "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
      }
    ],
    "resolution": "1080p",
    "ratio": "16:9",
    "duration": 5,
    "watermark": false
  }'

Réponse immédiate avec ID de tâche :

{"id": "cgt-2025xxxxxxxx-xxxx"}

Exemple Python (SDK officiel)

Installez le SDK :

pip install volcenginesdkarkruntime

Soumettez une tâche :

import os
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A golden retriever running through a sunlit wheat field, wide tracking shot, cinematic"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

print(resp.id)

Stockez l’ID de tâche pour l’interrogation suivante.

Le modèle de tâche asynchrone : soumettre, interroger, télécharger

La génération n’est pas instantanée (60 à 120s pour 5s en 1080p). Cycle de vie :

queued -> running -> succeeded
                 -> failed
                 -> expired
                 -> cancelled

Interrogez le point de terminaison GET jusqu’à obtention de succeeded.

Boucle d’interrogation Python complète

import os
import time
import requests
from volcenginesdkarkruntime import Ark

client = Ark(api_key=os.environ.get("ARK_API_KEY"))

# Étape 1 : soumettre
resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {"type": "text", "text": "Aerial shot of a mountain lake at sunrise, slow dolly forward"}
    ],
    resolution="1080p",
    ratio="16:9",
    duration=5,
    watermark=False,
)

task_id = resp.id
print(f"Tâche soumise : {task_id}")

# Étape 2 : interrogation avec backoff exponentiel
wait = 10
while True:
    result = client.content_generation.tasks.get(task_id=task_id)
    status = result.status
    print(f"Statut : {status}")

    if status == "succeeded":
        video_url = result.content.video_url
        print(f"URL de la vidéo : {video_url}")
        break
    elif status in ("failed", "expired", "cancelled"):
        print(f"Tâche terminée avec le statut : {status}")
        break

    time.sleep(wait)
    wait = min(wait * 2, 60)  # max 60s

# Étape 3 : télécharger immédiatement
if status == "succeeded":
    response = requests.get(video_url, stream=True)
    with open("output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    print("Téléchargé : output.mp4")

Le backoff exponentiel évite de surcharger l’API.

Image-vers-vidéo (I2V) : animer une image fixe

Pour animer une image, ajoutez un objet image_url au tableau content avec votre texte. L’image devient la première image de la vidéo.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The woman slowly turns her head and smiles at the camera"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/portrait.jpg"}
        }
    ],
    ratio="adaptive",
    duration=5,
    watermark=False,
)

Définir ratio à "adaptive" pour utiliser le ratio natif de l’image. Max 30 Mo/image, jusqu’à 9 images/requête.

Première et dernière image : contrôle des points de début et de fin

Vous pouvez fournir la première et la dernière image + une invite textuelle pour générer le mouvement intermédiaire.

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "The flower blooms from bud to full open, macro lens, soft light"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-bud.jpg"}
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/flower-open.jpg"}
        }
    ],
    ratio="adaptive",
    duration=8,
    watermark=False,
)

Incluez les deux images dans l’ordre : première image, puis dernière image. Utilisez return_last_frame: true pour chaîner plusieurs clips.

Référence multimodale : combiner images, vidéo et audio

Seedance 2.0 accepte images, vidéos et audio en entrée.

Types de contenu possibles :

{"type": "text", ...}
{"type": "image_url", ...}
{"type": "video_url", ...}
{"type": "audio_url", ...}

Limites :

Jusqu’à 9 images (30 Mo chacune)
3 clips vidéo (2-15s, 50 Mo chacun)
3 fichiers audio (MP3, 15 Mo chacun)

Exemple :

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "Match the visual style of the reference clip and add the provided background audio"
        },
        {
            "type": "image_url",
            "image_url": {"url": "https://example.com/style-reference.jpg"}
        },
        {
            "type": "video_url",
            "video_url": {"url": "https://example.com/motion-reference.mp4"}
        },
        {
            "type": "audio_url",
            "audio_url": {"url": "https://example.com/background-music.mp3"}
        }
    ],
    duration=10,
    ratio="16:9",
    watermark=False,
)

Inclure une référence vidéo réduit le coût (voir section prix).

Génération audio native

Activez generate_audio: true pour générer l’audio en même temps que la vidéo (dialogues, bruitages, musique, ambiance).

resp = client.content_generation.tasks.create(
    model="doubao-seedance-2-0-260128",
    content=[
        {
            "type": "text",
            "text": "A street musician plays guitar outside a cafe in Paris, crowds passing by, city sounds"
        }
    ],
    resolution="1080p",
    ratio="16:9",
    duration=10,
    generate_audio=True,
    watermark=False,
)

La génération audio augmente légèrement la consommation de jetons.

Contrôler la résolution, le rapport d’aspect et la durée

resolution : "480p", "720p", "1080p", "2K" (défaut : "1080p")
ratio : "16:9", "9:16", "4:3", "3:4", "21:9", "1:1", "adaptive"
duration : entier de 4 à 15 (secondes, défaut : 5)

Le modèle rapide (doubao-seedance-2-0-fast-260128) est utile pour le prototypage.

Cas d'usage Seedance 2.0 :

Génération audio-vidéo native
Contrôle images début/fin
Références multimodales

Lire le coût de la réponse

Une fois la tâche réussie, le champ usage indique la consommation de jetons :

{
  "usage": {
    "completion_tokens": 246840,
    "total_tokens": 246840
  }
}

Références :

1080p, 15s ≈ 308 880 jetons
1080p, 5s ≈ 102 960 jetons

Tarifs :

T2V/I2V 1080p : 46 yuans/Mjetons (~6,40 $)
V2V : 28 yuans/Mjetons (~3,90 $)

Calculez le coût : completion_tokens × tarif unitaire.

Important : téléchargez la vidéo dans les 24 heures

Le video_url expire après 24h. Après expiration : erreur 403, fichier supprimé. Téléchargez immédiatement à la complétion.

execution_expires_after donne la durée d’enregistrement de la tâche (172800s = 48h), mais l’URL vidéo = 24h max.
Historique des tâches limité à 7 jours.

Comment tester l'API Seedance avec Apidog

Le modèle asynchrone requiert plusieurs appels dépendants. Apidog permet de chaîner ces étapes.

Étape 1 : Créer un scénario de test

Dans Apidog, module Tests → nouveau scénario "Génération de vidéo Seedance 2.0"
Définissez la variable d’environnement ARK_API_KEY dans les paramètres
Utilisez {{ARK_API_KEY}} dans les requêtes

Étape 2 : Requête de soumission

Ajoutez une requête POST vers https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks
Header Authorization : Bearer {{ARK_API_KEY}}
Corps JSON avec model et content
Ajoutez un extracteur JSONPath $.id vers une variable TASK_ID

Étape 3 : Processeur d'attente

Ajoutez un délai de 30s après l’extraction

Étape 4 : Requête d’interrogation en boucle For

Ajoutez un bloc For (max 20 itérations) :
1. GET sur https://ark.cn-beijing.volces.com/api/v3/contents/generations/tasks/{{TASK_ID}}
2. Attente 10s
3. Condition de sortie : $.status == "succeeded" ou $.status == "failed"

Étape 5 : Assertions

Vérifiez que $.status == "succeeded" et que $.content.video_url n’est pas vide

Exécutez le scénario pour obtenir un rapport détaillé de chaque étape. Vous pouvez importer les endpoints Seedance directement depuis une commande cURL.

Détail des prix : combien coûte une vidéo de 10 secondes

La tarification est purement à la consommation de jetons.

Type de tâche	Tarif (pour 1M de jetons)
T2V / I2V en 1080p	46 yuans (~6,40 $)
V2V (entrée vidéo)	28 yuans (~3,90 $)

Coûts typiques en 1080p :

Durée	Jetons approx.	Coût (T2V/I2V)
5 secondes	~103,000	~0,66 yuan / ~0,93 $
10 secondes	~206,000	~9,48 yuans / ~1,32 $
15 secondes	~309,000	~14,21 yuans / ~1,97 $

Les crédits d’essai couvrent ≈8 générations complètes de 15s. Pour réduire le coût, commencez en 720p ou 480p.

Erreurs courantes et solutions

429 Trop de requêtes

Limite de concurrence atteinte (trop de tâches en parallèle). Implémentez un backoff exponentiel (départ 10s, doublez jusqu’à 60s max).

Statut "failed"

Invite non conforme, image corrompue/trop grande, paramètres invalides. Vérifiez et resoumettez.

Statut "expired"

Tâche trop longtemps en file d’attente. Resoumettez, pas de redémarrage possible.

403 sur video_url

L’URL a expiré (24h dépassées). Fichier supprimé. Régénérez avec les mêmes paramètres/seed.

Reproductibilité avec seed

Passez la valeur seed pour tenter de reproduire une vidéo identique.

Conclusion

L’API Seedance 2.0 permet une génération vidéo avancée, automatisable et multimodale. Modèle asynchrone simple : POST, interrogation GET, téléchargement immédiat. Les tests automatisés avec Apidog garantissent la robustesse de vos workflows avant déploiement réel.

FAQ

Q : Quelle est la différence entre doubao-seedance-2-0-260128 et doubao-seedance-2-0-fast-260128 ?

Le modèle standard offre une meilleure qualité pour la production. Le modèle rapide est utile pour le prototypage, mais la qualité visuelle est inférieure.

Q : Puis-je utiliser Seedance 2.0 en dehors de la Chine ?

Oui, même si l’API est hébergée à Pékin (latence accrue possible). Vérifiez les conditions Volcengine selon votre compte.

Q : Comment enchaîner plusieurs clips pour une vidéo longue ?

Activez return_last_frame: true pour chaque génération. Passez la dernière image comme première image du clip suivant. Assemblez les vidéos en post-production.

Q : La génération audio native coûte-t-elle plus cher ?

Oui, légèrement, car la génération audio-vidéo conjointe consomme plus de jetons.

Q : Peut-on recevoir un webhook au lieu d’interroger ?

Oui, ajoutez callback_url lors de la soumission. L’API POSTera le résultat à cette URL.

Q : Que se passe-t-il si je dépasse la limite de 9 images ?

Erreur 400 (validation). Réduisez à 9 images ou moins.

Q : Le paramètre seed garantit-il une reproduction exacte ?

Pas à 100 %, mais la sortie sera très proche, sauf changement de version serveur ou de paramètres.

Q : Comment suivre les dépenses sur plusieurs tâches ?

Lisez completion_tokens dans chaque réponse, multipliez par le tarif, stockez dans une base de données. Pas de dashboard intégré : implémentez votre suivi dès le début.

Comment utiliser l'API Grok de texte en vidéo : le guide complet

Antoine Laurent — Fri, 03 Apr 2026 08:49:32 +0000

TL;DR

L'API Grok de conversion texte-vidéo permet de générer des vidéos à partir d'une invite textuelle. Appelez POST /v1/videos/generations pour recevoir immédiatement un request_id, puis interrogez GET /v1/videos/{request_id} jusqu'à ce que le statut soit "done". Le modèle utilisé est grok-imagine-video, la tarification commence à 0,05 $ par seconde en 480p. Le SDK Python xAI gère l'interrogation automatiquement.

Essayez Apidog dès aujourd'hui

Introduction

xAI a généré 1,2 milliard de vidéos en janvier 2026, le mois suivant le lancement de l'API Grok texte-vidéo (28 janvier 2026). Le modèle s'est classé numéro un sur le classement texte-vidéo d'Artificial Analysis ce même mois, preuve de la robustesse de l'infrastructure à grande échelle.

Ce guide vous détaille chaque étape d'intégration : première requête, interrogation, réglage des paramètres, rédaction d'invites efficaces, utilisation d'images de référence, extension/édition de vidéos existantes, et choix du mode texte-vidéo. Vous apprendrez aussi à tester sans consommer de crédits grâce à Apidog Smart Mock.

💡 L'API fonctionne en mode asynchrone : votre frontend ne peut pas attendre que la vidéo soit prête pour afficher du contenu. Pour développer une interface utilisateur de génération vidéo sans dépenser de crédits à chaque test, simulez les points de terminaison de génération et d'interrogation avec Smart Mock d'Apidog. Votre équipe frontend peut avancer pendant que le backend se construit.

Qu'est-ce que l'API Grok de conversion texte-vidéo ?

L'API Grok texte-vidéo fait partie de la suite xAI (https://api.x.ai). Envoyez une invite textuelle, le modèle grok-imagine-video génère un clip vidéo à partir de zéro, aucune image source requise.

Elle complète un endpoint de génération d'images synchrone (POST /v1/images/generations, modèle grok-imagine-image, 0,02 $/image) et propose aussi des endpoints d’extension et d’édition vidéo.

Différence clé avec image-vidéo : le texte-vidéo ne prend que des mots, créant entièrement la scène et l’animation. Si vous souhaitez animer une image source, voir le guide de l'API Grok image-vidéo.

Fonctionnement : génération texte-vidéo asynchrone

Le flux d’appel est asynchrone (idéal pour les tâches longues) :

Envoyez une requête POST avec votre invite.
L’API retourne immédiatement un request_id.
La vidéo est générée côté xAI.
Interrogez le endpoint GET avec ce request_id à intervalle régulier.
Quand le statut devient "done", l’URL vidéo est disponible.

Ce modèle est standard pour les API génératives multimédia. Votre frontend doit donc afficher un indicateur de chargement jusqu’à réception de l’URL vidéo.

Prérequis

Compte xAI : console.x.ai
Clé API : Créez-la dans la console xAI, copiez-la et passez-la dans l’en-tête Authorization de chaque requête.

Exemple d’utilisation comme variable d’environnement :

export XAI_API_KEY="votre_clé_api_ici"

Facultatif : installez le SDK Python xAI pour accélérer l’intégration :

pip install xai-sdk

Votre première requête texte-vidéo

Endpoint : POST https://api.x.ai/v1/videos/generations

Champs obligatoires : model, prompt

Utilisation de curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Un golden retriever courant à travers les feuilles d'automne au ralenti, éclairage cinématographique"
  }'

Réponse immédiate :

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Utilisation de Python (requests)

import requests
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "model": "grok-imagine-video",
    "prompt": "Un golden retriever courant à travers les feuilles d'automne au ralenti, éclairage cinématographique"
}

response = requests.post(
    f"{BASE_URL}/v1/videos/generations",
    headers=headers,
    json=payload
)

data = response.json()
request_id = data["request_id"]
print(f"Génération démarrée. ID de requête : {request_id}")

Interroger pour le résultat vidéo

Une fois le request_id obtenu, interrogez GET /v1/videos/{request_id} jusqu’à ce que status soit "done".

Statuts possibles :

"processing" : génération en cours
"done" : vidéo prête (URL dans la réponse)
"failed" : erreur

Boucle d’interrogation Python :

import requests
import time
import os

API_KEY = os.environ["XAI_API_KEY"]
BASE_URL = "https://api.x.ai"

headers = {
    "Authorization": f"Bearer {API_KEY}"
}

def poll_video(request_id: str, interval: int = 5, max_attempts: int = 60) -> dict:
    url = f"{BASE_URL}/v1/videos/{request_id}"
    for attempt in range(max_attempts):
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")
        progress = data.get("progress", 0)
        print(f"Tentative {attempt + 1}: statut={status}, progression={progress}%")
        if status == "done":
            return data
        elif status == "failed":
            raise RuntimeError(f"La génération vidéo a échoué : {data}")
        time.sleep(interval)
    raise TimeoutError(f"Vidéo non prête après {max_attempts} tentatives")

def generate_video(prompt: str) -> str:
    response = requests.post(
        f"{BASE_URL}/v1/videos/generations",
        headers={**headers, "Content-Type": "application/json"},
        json={"model": "grok-imagine-video", "prompt": prompt}
    )
    request_id = response.json()["request_id"]
    print(f"ID de requête : {request_id}")
    result = poll_video(request_id)
    video_url = result["video"]["url"]
    print(f"Vidéo prête : {video_url}")
    return video_url

video_url = generate_video(
    "Un timelapse d'une skyline de ville au coucher du soleil passant à la nuit, vue aérienne"
)

Réponse d’interrogation terminée :

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 500000000
  }
}

Utilisation du SDK Python xAI

Le SDK xAI gère l’interrogation et attend que la vidéo soit prête :

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

result = client.video.generate(
    model="grok-imagine-video",
    prompt="Un golden retriever courant à travers les feuilles d'automne au ralenti",
    duration=8,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"URL de la vidéo : {result.video.url}")
print(f"Durée : {result.video.duration}s")

Utilisez le SDK pour accélérer l’intégration. Passez à l’approche requests pour un contrôle fin sur la logique d’interrogation.

Rédiger des invites efficaces pour la génération vidéo

Description de la scène : Soyez précis sur le sujet et l’environnement.
Mouvement : Décrivez ce qui bouge et comment.
Style de caméra : Utilisez des termes de cinéma ("gros plan", "dolly zoom", etc.).
Éclairage et ambiance : Spécifiez l’ambiance ("heure dorée", "lumière studio").
Références de style : Citez un style ("anime", "cinématique", etc.).

Structure recommandée :

Un astronaute solitaire flotte devant la Station Spatiale Internationale,
la ligne de vie flottant derrière lui. La caméra suit lentement
à ses côtés, montrant la Terre en dessous. Cinématique, qualité IMAX,
lumière chaude du lever du soleil se reflétant sur la visière.

Contrôle des paramètres : résolution, durée, rapport d’aspect

Durée : 1 à 15 secondes ("duration": 10). Par défaut : 6s.
Résolution : "480p" (par défaut) ou "720p" ; 480p pour le prototypage, 720p pour la prod.
Aspect ratio : "16:9", "9:16", "1:1", "4:3", "3:4", "3:2", "2:3"

Rapport	Idéal pour
16:9	Bureau, YouTube, présentations
9:16	TikTok, Instagram Reels, mobile
1:1	Fil Instagram, cartes sociales
4:3	Vidéo classique, présentations
3:4	Contenu mobile portrait
3:2	Rapport photo standard
2:3	Photographie portrait

Exemple complet :

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "Une ville côtière à l'aube, des vagues déferlant doucement sur un rivage rocheux",
    "duration": 10,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Utiliser des images de référence

Le paramètre reference_images accepte un tableau de jusqu’à 7 URL. Ces images influencent le style et le contenu visuel sans devenir le sujet principal.

{
  "model": "grok-imagine-video",
  "prompt": "Une ville côtière à l'aube, des vagues déferlant doucement sur un rivage rocheux",
  "reference_images": [
    {"url": "https://example.com/ma-reference-de-style.jpg"},
    {"url": "https://example.com/reference-palette-de-couleurs.jpg"}
  ]
}

Privilégiez des images cohérentes en style pour de meilleurs résultats.

Extension et édition de vidéos générées

Étendre une vidéo : POST /v1/videos/extensions (ajoute des séquences, utilise le request_id original et une nouvelle invite).
Modifier une vidéo : POST /v1/videos/edits (modifie style, scène ou effets par instruction textuelle).

Ces endpoints sont également asynchrones et renvoient un request_id utilisé pour interroger le résultat.

Suivi du coût depuis la réponse API

L’objet usage contient le coût en "USD ticks" :

"usage": {
  "cost_in_usd_ticks": 500000000
}

Divisez par 10 000 000 pour obtenir le montant en dollars.

cost_in_usd = result["usage"]["cost_in_usd_ticks"] / 10_000_000
print(f"Coût : ${cost_in_usd:.4f}")
# Sortie : Coût : 0,0500 $

Résolution	Prix/seconde	10s
480p	0,05 $	0,50 $
720p	0,07 $	0,70 $

Gardez une trace de cost_in_usd_ticks pour suivre vos coûts sans requêtes supplémentaires.

Tester l’API vidéo Grok avec Apidog

Le modèle asynchrone impose de tester trois états frontend : chargement, succès, erreur. Impossible de tout tester en prod sans dépenser des crédits et du temps. Utilisez la fonction Smart Mock d’Apidog :

Cas d’utilisation 1 : Smart Mock pour le développement frontend

Simuler le endpoint de génération : Créez POST /v1/videos/generations dans Apidog, schéma de réponse :

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

Simuler le endpoint d’interrogation : Créez GET /v1/videos/{request_id} avec schéma complet et Mock personnalisé :

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/mock-video-12345.mp4",
    "duration": 8,
    "respect_moderation": true
  },
  "progress": 100,
  "usage": {
    "cost_in_usd_ticks": 400000000
  }
}

Testez tous les états frontend sans consommer de crédits.

Cas d’utilisation 2 : Scénarios de test pour la boucle d’interrogation

Étape 1 : Ajoutez POST /v1/videos/generations dans le scénario de test, extrayez request_id avec JSONPath $.request_id dans une variable videoRequestId.
Étape 2 : Ajoutez GET /v1/videos/{{videoRequestId}} dans une boucle For, condition d’arrêt : response.body.status == "done" ; ajoutez un délai entre les itérations.
Étape 3 : Assertion finale : $.video.url n’est pas vide.

Automatisez ces tests pour valider votre logique end-to-end à chaque modification.

Texte-vers-vidéo ou image-vers-vidéo : quand utiliser quoi

Les deux modes utilisent grok-imagine-video, mais pour des usages différents.

Utilisez texte-vers-vidéo si :

Vous partez d’un concept ou script original
Le modèle doit composer la scène entièrement
L’utilisateur saisit une invite textuelle
Pas d’image source

Utilisez image-vers-vidéo si :

Vous animez une photo, illustration ou asset de marque
Vous devez préserver des détails visuels d’une image
Animation cohérente à partir d’une série d’images
Animation d’œuvre d’art/photo existante

Le texte-vidéo crée une scène de zéro ; l’image-vidéo anime une image existante. Pour approfondir le mode image-vidéo, consultez le guide de l'API Grok image-vers-vidéo.

Pour un produit hybride, détectez le type d’entrée à l’exécution et routez vers le bon endpoint.

Erreurs courantes et solutions

401 Non autorisé : Clé API absente, expirée ou mal formatée. Vérifiez l’en-tête Authorization.
429 Trop de requêtes : Limite atteinte (60/min, 1/s). Ajoutez un délai entre les requêtes, interrogez toutes les 5s.
statut "failed" : Invite rejetée par la modération. Vérifiez/simplifiez votre invite.
URL vidéo 404 : Les URL expirent rapidement. Téléchargez la vidéo dès réception.
Vidéo figée/vide : Invite trop vague, manque de mouvement explicite. Ajoutez des indications précises.
Interrogation lente : Les vidéos 720p et longues sont plus lentes. Pour le développement, utilisez 480p et des durées courtes.

Conclusion

L’API Grok texte-vidéo offre une génération vidéo asynchrone, pilotée par invite. Maîtrisez la boucle d’interrogation, puis ajustez durée, résolution, aspect et images de référence selon vos besoins.

Pour la production, suivez les coûts via cost_in_usd_ticks. Simulez vos endpoints dans Apidog pour un développement frontend efficace et des tests automatisés fiables.

Téléchargez Apidog gratuitement pour configurer vos mocks et scénarios de test pour l’API vidéo Grok.

FAQ

Quel nom de modèle dois-je utiliser pour la génération texte-vidéo ?

Utilisez grok-imagine-video dans le champ model de votre requête POST.

Combien de temps prend la génération vidéo ?

Cela dépend de la durée et de la résolution. Un clip court en 480p peut être prêt en moins de 30 secondes. Pour 720p ou des clips longs, prévoir plusieurs minutes. Interrogez toutes les 5-10s.

Peut-on générer une vidéo de plus de 15 secondes ?

Non, la durée maximale est 15s par requête. Pour des séquences plus longues, générez puis étendez avec POST /v1/videos/extensions.

Comment télécharger la vidéo générée ?

Récupérez l’URL dans result.video.url de la réponse finale et téléchargez immédiatement le MP4 (l’URL est temporaire).

Que se passe-t-il si l’invite enfreint la modération de contenu ?

La tâche sera "failed". Le champ respect_moderation indique l’application de la modération. Révisez et reformulez votre invite.

Existe-t-il un niveau gratuit pour l’API vidéo ?

La facturation se fait à la seconde générée. Consultez console.x.ai pour les éventuelles offres de crédit.

Quelle différence entre reference_images et une image source ?

reference_images guide le style pour le texte-vidéo. Pour que l’image soit l’élément principal animé, utilisez le mode image-vidéo.

Comment tester la boucle d’interrogation sans dépenser des crédits ?

Utilisez Smart Mock d’Apidog pour simuler les endpoints. Configurez des réponses mock pour "processing" et "done" et testez votre code sans toucher à l’API réelle.

Comment utiliser l'API image en vidéo de Grok : guide pas à pas

Antoine Laurent — Fri, 03 Apr 2026 08:44:12 +0000

En bref

L'API image-vers-vidéo de Grok permet d'animer une image statique en un clip vidéo à l'aide du modèle grok-imagine-video. Pour l'utiliser, envoyez (POST) l’URL de votre image, un prompt et des paramètres optionnels à https://api.x.ai/v1/videos/generations. L’API retourne immédiatement un request_id. Vous devez ensuite interroger (poll) GET /v1/videos/{request_id} jusqu’à ce que le champ status passe à "done". La génération prend entre 1 et 15 secondes de vidéo. Tarification : à partir de 0,05 $/seconde en 480p.

Essayez Apidog dès aujourd'hui

Introduction

Le 28 janvier 2026, xAI a lancé le modèle grok-imagine-video en accès public via API. En un mois, il a généré 1,2 milliard de vidéos et s'est hissé en tête du classement "text-to-video" d’Artificial Analysis. L’animation d’une photo en vidéo est l’une de ses fonctions principales : fournissez une photo et une invite descriptive, et l’API génère un clip MP4 animé à télécharger.

Ce flux asynchrone — soumission d’une tâche puis interrogation de son état — pose un défi de test que beaucoup de développeurs sous-estiment. Une intégration n’est pas terminée après le premier POST 200, mais lorsque la boucle de polling gère correctement les états "processing", "done" et "failed" dans des conditions réelles.

Les Scénarios de Test d’Apidog apportent une solution directe : construisez une séquence chaînée (POST /v1/videos/generations, extraction du request_id, boucle d’interrogation jusqu’à status == "done", puis assertion sur la présence de l’URL vidéo). Suivez ce guide pour mettre en place votre workflow de test.

Qu'est-ce que l'API Grok image-vers-vidéo ?

L’API Grok image-vers-vidéo fait partie du produit vidéo de xAI. Elle utilise le modèle grok-imagine-video et prend une image comme première frame de la vidéo générée. Le modèle analyse l’image et le prompt, puis génère un mouvement naturel pour l’animer.

Endpoint API :

POST https://api.x.ai/v1/videos/generations

Authentification :

Authorization: Bearer YOUR_XAI_API_KEY

Obtenez votre clé API sur la console xAI. Cette API supporte également le texte-vers-vidéo (sans paramètre image), l’extension et la modification vidéo.

Fonctionnement du processus image-vers-vidéo

Le paramètre image du body représente la première image de la vidéo. Le modèle anime la scène depuis cette image, chaque pixel initial provient de votre source. Ensuite, selon votre prompt, la scène évolue.

Exemple : une photo d’un lac de montagne au lever du soleil, avec le prompt : « De douces ondulations se propagent à la surface de l’eau tandis que la brume matinale s’élève. » La première frame sera la photo ; les frames suivantes montrent l’animation de l’eau et de la brume.

Différence par rapport au texte-vers-vidéo : le texte-vers-vidéo génère la première image, tandis qu’image-vers-vidéo vous donne un contrôle précis sur la scène initiale.

Utilisez image-vers-vidéo si :

Vous souhaitez animer des photos de produits, paysages, portraits existants.
Votre branding nécessite une identité visuelle cohérente.
Le mouvement doit partir d’une scène réelle.

Utilisez texte-vers-vidéo si :

Vous n’avez pas d’image de référence.
Vous laissez le modèle choisir la composition.
L’itération rapide prime sur la fidélité à une image.

Prérequis

Avant de commencer :

Compte xAI sur console.x.ai.
Clé API depuis la console xAI (stockez-la dans une variable d’environnement).
Python 3.8+ ou Node.js 18+ (exemples pour les deux).
URL d’image publique ou image encodée en base64 (data URI).

Définissez la clé API :

export XAI_API_KEY="votre_clé_ici"

Installez le SDK Python xAI (optionnel) :

pip install xai-sdk

Pour les appels HTTP bruts : utilisez requests (Python) ou fetch (Node.js).

Effectuer votre première requête image-vers-vidéo

Utilisation de curl

curl -X POST https://api.x.ai/v1/videos/generations \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "prompt": "De douces vagues se déplacent à la surface, la brume matinale s'élève lentement",
    "image": {
      "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
  }'

Réponse immédiate :

{
  "request_id": "d97415a1-5796-b7ec-379f-4e6819e08fdf"
}

La génération est asynchrone. Passez à l’étape d’interrogation.

Utilisation de Python (requêtes brutes)

import os
import requests

api_key = os.environ["XAI_API_KEY"]

payload = {
    "model": "grok-imagine-video",
    "prompt": "De douces vagues se déplacent à la surface, la brume matinale s'élève lentement",
    "image": {
        "url": "https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/24701-nature-natural-beauty.jpg/1280px-24701-nature-natural-beauty.jpg"
    },
    "duration": 6,
    "resolution": "720p",
    "aspect_ratio": "16:9"
}

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

response = requests.post(
    "https://api.x.ai/v1/videos/generations",
    json=payload,
    headers=headers
)

data = response.json()
request_id = data["request_id"]
print(f"Tâche démarrée : {request_id}")

Utilisation d'une image Base64

Pour une image locale/non publique :

import base64

with open("my_image.jpg", "rb") as f:
    encoded = base64.b64encode(f.read()).decode("utf-8")

payload["image"] = {
    "url": f"data:image/jpeg;base64,{encoded}"
}

Interrogation du résultat

La génération vidéo étant asynchrone, interrogez :

GET https://api.x.ai/v1/videos/{request_id}

Statuts possibles :

Statut	Signification
`"processing"`	Vidéo en cours de rendu
`"done"`	Vidéo prête, URL disponible
`"failed"`	Une erreur est survenue

Réponse complète :

{
  "status": "done",
  "video": {
    "url": "https://vidgen.x.ai/....mp4",
    "duration": 6
  },
  "progress": 100
}

Boucle d'interrogation Python complète

import time

def poll_video(request_id: str, api_key: str, interval: int = 5) -> dict:
    url = f"https://api.x.ai/v1/videos/{request_id}"
    headers = {"Authorization": f"Bearer {api_key}"}

    while True:
        response = requests.get(url, headers=headers)
        data = response.json()
        status = data.get("status")

        print(f"Statut : {status} | Progression : {data.get('progress', 0)}%")

        if status == "done":
            return data["video"]
        elif status == "failed":
            raise RuntimeError(f"La génération vidéo a échoué pour {request_id}")

        time.sleep(interval)

# Utilisation
video = poll_video(request_id, api_key)
print(f"URL de la vidéo : {video['url']}")
print(f"Durée : {video['duration']}s")

Gardez un intervalle d’au moins 5 s. Limite d’API : 60 requêtes/minute (1/s).

Utilisation du SDK Python xAI

Le package xai-sdk gère pour vous la logique asynchrone :

from xai_sdk import Client
import os

client = Client(api_key=os.environ["XAI_API_KEY"])

video = client.video.generate(
    model="grok-imagine-video",
    prompt="De douces vagues se déplacent à la surface, la brume matinale s'élève lentement",
    image={"url": "https://example.com/landscape.jpg"},
    duration=6,
    resolution="720p",
    aspect_ratio="16:9"
)

print(f"URL de la vidéo : {video.url}")
print(f"Durée : {video.duration}s")

Le SDK s’occupe du polling, des erreurs, etc. Pour un contrôle granulaire sur la boucle ou les logs, utilisez les requêtes brutes.

Contrôle de la résolution, de la durée et du rapport d’aspect

L’API offre un contrôle précis sur la sortie :

Durée

duration : entier de 1 à 15 secondes (par défaut : 6).

"duration": 10

Plus la vidéo est longue, plus le coût augmente.

Résolution

Valeur	Description
`"480p"`	Par défaut. Moins cher, plus rapide.
`"720p"`	Qualité supérieure. 0,07 $/sec vs 0,05 $

"resolution": "720p"

Rapport d’aspect

Valeur	Cas d'utilisation
"16:9"	Par défaut, paysage
"9:16"	Vertical, stories/mobile
"1:1"	Carré, réseaux sociaux/thumbnails
"4:3"	Photo/presentation classique
"3:4"	Portrait
"3:2"	Photo standard
"2:3"	Portrait haut

Par défaut, l’aspect ratio suit celui de l’image source. Spécifiez-le pour forcer un recadrage.

Utilisation d’images de référence pour l’orientation stylistique

Le paramètre reference_images est différent de image :

image : Première image de la vidéo (point de départ pour l’animation).
reference_images : Tableau (max 7) d’images qui guident le style, le contenu ou le contexte. Elles influencent l’apparence, sans être affichées.

Exemple d’usage :

{
  "model": "grok-imagine-video",
  "prompt": "Un produit tournant lentement sur une surface blanche propre",
  "image": {
    "url": "https://example.com/product-shot.jpg"
  },
  "reference_images": [
    {"url": "https://example.com/brand-style-reference-1.jpg"},
    {"url": "https://example.com/lighting-reference.jpg"}
  ],
  "duration": 6,
  "resolution": "720p"
}

Ici, product-shot.jpg est la première image ; les références influencent le style/éclairage.

Vous pouvez utiliser uniquement des images de référence (sans image) pour guider un texte-vers-vidéo.

Extension et édition de vidéos

Deux opérations avancées :

Extension d’une vidéo

POST /v1/videos/extensions : ajoute des secondes à une vidéo existante (max 15 s par appel).

curl -X POST https://api.x.ai/v1/videos/extensions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "votre_request_id_original",
    "prompt": "La brume continue de se lever alors que la lumière du soleil perce",
    "duration": 5
  }'

Interrogez ensuite GET /v1/videos/{request_id} comme précédemment.

Modification d’une vidéo

POST /v1/videos/edits : modifie le contenu ou le mouvement d’une vidéo existante sur la base d’un nouveau prompt.

curl -X POST https://api.x.ai/v1/videos/edits \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-imagine-video",
    "video_id": "votre_request_id_original",
    "prompt": "Changer le ciel en un coucher de soleil dramatique avec des tons orange profond"
  }'

Extensions et modifications utilisent aussi le modèle asynchrone.

Détail des prix : combien coûte une vidéo de 10 s ?

L’API facture :

Le traitement de l’image d’entrée
La durée de la vidéo de sortie

Composant	Coût
Image d’entrée	0,002 $ / image
Sortie en 480p	0,05 $ / seconde
Sortie en 720p	0,07 $ / seconde

Exemple (10 s en 720p) :

Image d’entrée : 0,002 $
Sortie : 10 × 0,07 $ = 0,70 $
Total : 0,702 $

Exemple (6 s en 480p) :

Image d’entrée : 0,002 $
Sortie : 6 × 0,05 $ = 0,30 $
Total : 0,302 $

À chaque génération, le coût de l’image d’entrée s’applique, même avec la même URL.

Le texte-vers-vidéo ne facture pas de coût d’image.

Comment tester votre intégration de l’API vidéo Grok avec Apidog

Pour tester correctement une API asynchrone, validez :

La génération retourne bien un request_id
Le polling gère l’état "processing" pendant l’attente
La réponse finale a status == "done" et une URL vidéo non vide

Les Scénarios de Test d’Apidog permettent d’automatiser ce workflow.

Étape 1 : Créer un nouveau scénario de test

Dans Apidog, module Tests → bouton + → nommer (« Flux asynchrone Grok image-vers-vidéo »).

Étape 2 : Ajouter la requête de génération

URL : https://api.x.ai/v1/videos/generations
Méthode : POST
En-tête : Authorization: Bearer {{xai_api_key}}
Body JSON :

{
  "model": "grok-imagine-video",
  "prompt": "Une douce brume s'élève de l'eau tandis que la lumière filtre à travers les arbres",
  "image": {
    "url": "https://example.com/your-test-image.jpg"
  },
  "duration": 6,
  "resolution": "480p"
}

Étape 3 : Extraire le request_id

Processeur "Extraire Variable" :
- Nom : video_request_id
- Source : corps de la réponse
- Méthode : JSONPath : $.request_id

Étape 4 : Boucle d’interrogation

Processeur "For" (boucle) ; à l’intérieur :
- Requête GET : https://api.x.ai/v1/videos/{{video_request_id}}
- Header : Authorization: Bearer {{xai_api_key}}
- Extraction "video_status" : JSONPath $.status
- Attendre 5000ms pour éviter la limite de débit
- Condition d’arrêt de boucle : {{video_status}} == "done"

Étape 5 : Assertion sur l’URL vidéo

Requête GET finale
Processeur "Assertion" :
- Champ : $.video.url
- Condition : "n’est pas vide"

Vous pouvez intégrer ce scénario dans votre pipeline CI/CD avec la CLI Apidog :

apidog run --scenario grok-video-async-flow --env production

Erreurs courantes et corrections

401 Non autorisé : Clé API manquante/invalide. Vérifiez l’en-tête Authorization.

422 Entité non traitable : Body malformé, champ model ou prompt manquant, ou image non accessible.

URL d’image non accessible : L’URL doit être publique. Les URLs privées ou localhost échouent. Pour les images locales, utilisez un data URI base64.

Statut bloqué sur "processing" : Patientez jusqu’à 10 min. Si bloqué, renvoyez la requête.

Limite de débit (429) : Maximum 60 requêtes/minute (1/s). Ajoutez un time.sleep(1) entre les polls si besoin.

Erreur Base64 : Vérifiez que l’URI commence par le bon préfixe MIME (data:image/jpeg;base64,).

Mauvais aspect ratio : Si le ratio ne correspond pas, le modèle peut recadrer ou ajouter des bandes noires. Idéal : faites correspondre le ratio à l’image source.

Conclusion

L’API Grok image-vers-vidéo transforme une photo statique en clip animé : POST de l’image et du prompt, extraction du request_id, polling jusqu’à complétion, téléchargement du MP4. Le modèle grok-imagine-video domine le classement Artificial Analysis (janvier 2026) avec plus d’un milliard de vidéos générées ce mois-là.

La gestion du polling asynchrone est la principale difficulté d’intégration. Avec Apidog, créez des tests qui extraient les variables, bouclent sur l’état et valident le résultat, pour détecter les problèmes avant la production.

Commencez à construire votre intégration avec Apidog gratuitement. Aucune carte bancaire requise.

FAQ

Quel nom de modèle pour l’API Grok image-vers-vidéo ?

Utilisez grok-imagine-video dans le champ model du POST.

Différence entre image et reference_images ?

image : première image de la vidéo.

reference_images : indications de style et de contenu, non utilisées comme frame de départ. Vous pouvez les combiner.

Temps de génération d’une vidéo ?

6 s en 480p : 1–3 min.

15 s en 720p : 4–8 min.

Interrogez toutes les 5 s pour éviter la limite.

Utiliser un fichier local ?

Oui, encodez-le en base64 : data:image/jpeg;base64,{octets_encodes}.

Que se passe-t-il si je ne précise pas aspect_ratio ?

Avec image, le ratio suit l’image source. Sans image (texte-vers-vidéo), défaut : 16:9.

Tarif d’une vidéo 10 s 720p ?

Image d’entrée : 0,002 $. Sortie : 0,70 $. Total : 0,702 $.

Quelles limites de débit ?

60 requêtes/minute, 1/s. POST + GET combinés.

Prolonger une vidéo >15 s ?

Oui, via POST /v1/videos/extensions en générant plusieurs fragments successifs.

Prix de l'API SMS de Bird en 2026 : Combien ça coûte ?

Antoine Laurent — Fri, 03 Apr 2026 07:12:52 +0000

En bref

L'API SMS de Bird commence à 0,00331 $ par message sortant aux États-Unis et 0,003 $ par message entrant aux États-Unis. C'est l'un des tarifs les plus compétitifs du marché pour une API SMS. Vous disposez également d'un plan gratuit avec 5 SMS/jour pour tester rapidement votre intégration. Le plan Pro à 49 $/mois inclut 1 000 crédits SMS.

Essayez Apidog dès aujourd'hui

Introduction

MessageBird est devenu Bird en 2023, recentrant la plateforme sur la communication omnicanale (SMS, WhatsApp, e-mail, voix) avec une grille tarifaire transparente et un coût des SMS inférieur à Twilio, Vonage et autres grands acteurs.

💡 Astuce Développeur : Pour tout projet d’intégration SMS, il faut :

Des données tarifaires précises
Un moyen simple de tester vos appels API avant la production

Apidog répond à ces deux besoins : construisez vos requêtes API Bird, exécutez vos scénarios de test et validez les réponses sans code additionnel. Testez gratuitement et validez votre intégration SMS Bird en quelques minutes.

Cet article détaille les coûts des SMS Bird pour 2025/2026, les facteurs d’augmentation de facture et une comparaison avec les alternatives.

Aperçu des tarifs SMS de Bird

Bird applique une tarification en deux volets :

Frais de plan de plateforme (abonnement mensuel)
Frais par message (paiement à l’usage en supplément du plan)

Plan	Coût mensuel	SMS inclus
Gratuit	$0	5 SMS/jour
Pro	$49	1 000 SMS/mois
Entreprise	Personnalisé	Volume adapté

Au-delà du quota inclus, les tarifs US sont :

SMS sortants : 0,00331 $/message
SMS entrants : 0,003 $/message

Les tarifs CRM/Marketing de Bird sont en EUR sur la page officielle. Pour le niveau API/développeur, vérifiez toujours la grille tarifaire en vigueur pour éviter les surprises dues aux frais opérateurs ou taux de change.

Répartition des tarifs : SMS, MMS, WhatsApp et e-mail

SMS

US : 0,00331 $/message sortant (base opérateur directe)
Les tarifs varient selon les pays (voir extrait ci-dessous) :

Pays	Tarif sortant (approx.)
États-Unis	~$0.00331
Royaume-Uni	~€0.036
Australie	~€0.009
Allemagne	~€0.056
Inde	varie
Brésil	~€0.047

⚠️ Des frais opérateurs (10DLC, numéros verts) s’ajoutent pour les US/Canada. Voir "Coûts cachés".

MMS

Plus cher que le SMS : attendez-vous à ~3-5x le coût du SMS.
Disponible pour US et Canada.
Consultez bird.com/en/pricing/sms pour le tarif exact par pays/plan.

Deux éléments de tarification :

Frais Bird (par 1 000 messages) :

| Volume | Frais/1 000 messages |
|--------------------|---------------------|
| 1 – 1 000 | $0.001 |
| 1 001 – 100 000 | $0.005 |
| 100 001 – 500 000 | $0.0045 |
| 500 001+ | $0.004 |

Frais Meta (par conversation, varient selon le type/pays) :
- Marketing : 0,0250 $
- Utilitaire : 0,0034 $
- Authentification : 0,0034 $

Bird répercute les frais Meta sans surcoût.

E-mail

Démarre à 0,001 $/e-mail (faible volume)
Le plan Pro inclut 10 000 e-mails/mois
Canal le plus économique

Voix

Tarification à l’usage, variable selon le pays
Appels sortants US : 0,013–0,015 $/minute
Appels entrants US : un peu moins cher
Pour de gros volumes, contactez le service commercial Bird

Ce qui influence votre facture Bird

1. Pays et routage opérateur

Les tarifs varient fortement par pays. Exemple : Allemagne (~0,056 €), Bangladesh (~0,208 €), Burundi (~0,269 €), soit jusqu'à 80x le tarif US. Consultez toujours la grille par pays.

2. Type de numéro

Codes longs (10DLC) : Numéro standard US, nécessite enregistrement via TCR.
Codes courts : 5-6 chiffres, débit élevé, location mensuelle coûteuse (500–1 000 $/mois).
Numéros verts : Coût mensuel modéré, débit moyen.

Des frais de location mensuels s’ajoutent au tarif par message.

3. Longueur et encodage du message

160 caractères max (GSM-7). Dépassement → segmentation multiple (facturés individuellement).
Unicode (emoji, accents) : segment = 70 caractères.
1 emoji dans 200 caractères = 3 segments facturés.

4. Mix des canaux

Les workflows omnicanaux (ex : bascule SMS → WhatsApp) induisent des coûts WhatsApp en plus. Testez l’impact financier avant d’activer ces automatisations.

5. Volume

Pas de remises publiques Bird sur le volume. Pour de gros volumes, le plan Enterprise offre des tarifs négociés. Contactez le support commercial.

Coûts et frais cachés

Frais d’opérateur US (10DLC)

Enregistrement de marque : frais unique (~4 à 44 $)
Enregistrement de campagne : ~10 $/mois/campagne
Surtaxe opérateur/message : quelques centimes ajoutés au tarif Bird

Fixés par les opérateurs (AT&T, T-Mobile, Verizon), non par Bird.

Location de numéro

Long code US : 1–2 $/mois
Numéro vert : 2–3 $/mois
Code court : 500–1 000 $/mois

Webhooks entrants et traitement

Chaque SMS entrant : 0,003 $ (US)
Les flux automatisés (désabonnement, aide) génèrent des messages entrants facturés.

Abonnement plateforme

Pro : 49 $/mois (1 000 SMS inclus)
Au-delà, chaque SMS est facturé à l’unité.
Pour de gros volumes, le forfait inclus est vite dépassé.

Comparatif Bird vs alternatives

Fournisseur	SMS sortants US	SMS entrants US	Remarques
Bird	$0.00331	$0.003	Tarif de base le plus bas, plateforme omni
Twilio	$0.0079	$0.0079	Plus cher, écosystème riche
Telnyx	~$0.004	~$0.001	Compétitif, modèle direct opérateur
Plivo	$0.0055	$0.0005	Entrant très bas, plateforme simple

Bird propose le tarif sortant US le plus bas. Twilio coûte plus du double au niveau d’entrée, même si ses remises volume réduisent l’écart. Bird regroupe SMS, WhatsApp, e-mail et automatisation – à choisir si vous ciblez l’omnicanal. Si vous cherchez une simple API SMS, Telnyx ou Plivo proposent une grille plus simple.

Comment démarrer avec Bird

Créer un compte gratuit sur bird.com. Profitez de 5 SMS/jour sans carte de crédit.
Enregistrer votre marque et campagne via le dashboard Bird (conformité 10DLC US). Comptez 1–3 jours ouvrés.
Obtenir un numéro de téléphone via l’API Numbers Bird ou le dashboard.
Effectuer votre premier appel API. Bird utilise une API REST JSON.

Exemple d’appel API pour envoyer un SMS :

curl -X POST "https://api.bird.com/v1/messages" \
  -H "Authorization: AccessKey VOTRE_CLE_API" \
  -H "Content-Type: application/json" \
  -d '{
    "originator": "NUMERO_EMETTEUR",
    "recipients": ["NUMERO_DESTINATAIRE"],
    "body": "Bonjour depuis l’API Bird !"
  }'

La documentation Bird détaille l’authentification, les SDK (Node.js, Python, PHP, Go, Java, Ruby) et la gestion des webhooks.

Conclusion

L’API SMS Bird affiche le tarif de base le plus bas du marché US (0,00331 $/message sortant). Le plan gratuit vous permet de tester sans CB. Le plan Pro (49 $/mois, 1 000 SMS inclus) est adapté aux équipes en phase de démarrage.

Points de vigilance : frais opérateur 10DLC, location de numéro, tarifs internationaux (jusqu'à 50x le prix US). Intégrez-les dans votre modèle de coût dès le départ.

Pour évaluer Bird, testez votre intégration de bout en bout avec Apidog : création de requêtes, gestion d’environnements, enchaînement de tests et assertions de livraison, tout-en-un.

FAQ

Quel est le prix de l'API SMS de Bird par message aux États-Unis ?

0,00331 $ par SMS sortant US, 0,003 $ par SMS entrant US (tarif API développeur). Des frais opérateur (10DLC) s’ajoutent.

Bird est-il la même chose que MessageBird ?

Oui. MessageBird est devenu Bird en 2023. L’entreprise existe depuis 2011 et a des clients comme Heineken, Booking.com, Uber, eBay. L’API et certaines docs référencent encore MessageBird.

Bird facture-t-il les SMS entrants ?

Oui, 0,003 $/SMS entrant US. Les réponses désabonnement/aide comptent comme entrants.

Qu'est-ce que le plan gratuit de Bird ?

5 SMS/jour, 10 e-mails/jour, 15 messages IA/jour. Accès API public sans CB, idéal pour tester avant le Pro.

Comment la tarification SMS de Bird se compare-t-elle à celle de Twilio ?

Bird : 0,00331 $/sortant US ; Twilio : 0,0079 $. Pour 100 000 messages/mois, Bird = 331 $ vs Twilio = 790 $. Twilio propose des remises volume.

Y a-t-il des frais cachés avec les SMS Bird ?

Oui : frais d’enregistrement marque/campagne 10DLC, surtaxes opérateur/message, location numéro (1–2 $/mois), tarifs internationaux élevés.

Comment tester l’API SMS de Bird sans envoyer de vrais messages ?

Utilisez la fonction Smart Mock d’Apidog pour simuler les réponses Bird. Vous pouvez aussi envoyer des tests à votre numéro via le sandbox Bird. Les scénarios Apidog permettent d’enchaîner requêtes et vérifications sans toucher la production.

Prix SMS Twilio API : Analyse Complète des Tarifs 2026

Antoine Laurent — Fri, 03 Apr 2026 04:01:47 +0000

En bref

SMS code long US (envoi et réception) : 0,0083 $ par message
MMS envoi : 0,022 $ par message ; MMS réception : 0,0165 $ par message
SMS numéro gratuit : 0,0083 $ par message plus les frais d'opérateur
Location de code court : 1 000 $/mois pour un code aléatoire ; 1 500 $/mois pour un code personnalisé
Enregistrement de marque 10DLC : 4,50 $ de frais uniques (mis à jour en août 2025) ; campagnes de 1,50 $ à 10 $/mois
Numéro de téléphone (code long) : 1,15 $/mois ; numéro gratuit : 2,15 $/mois
Les frais d'opérateur s'ajoutent à tous les prix de base
Les remises sur volume s'appliquent automatiquement à partir de 150 000 messages par mois
Essai gratuit disponible ; aucune carte de crédit requise pour commencer

Introduction

Twilio est l'API SMS par défaut pour la plupart des équipes de développeurs. Sa documentation est complète, la disponibilité est fiable et l'API REST est bien conçue. Mais dès que vous passez d'un projet annexe à une application de production, la facture augmente rapidement. Vous ne payez pas un seul prix par message, mais le tarif de base Twilio, des frais d'opérateur, des frais de numéro de téléphone et, souvent, des coûts d'enregistrement 10DLC en sus.

Essayez Apidog dès aujourd'hui

💡 Astuce : Avant de développer votre intégration SMS, testez-la correctement. Apidog vous permet de créer des scénarios de test automatisés pour valider les réponses de vos webhooks Twilio avec votre spécification OpenAPI. Confirmez les codes de statut, validez les schémas de réponse, et exécutez des tests de contrat en CI/CD. Essayez Apidog gratuitement pour vérifier vos workflows SMS avant la production.

Cet article détaille chaque poste de la tarification Twilio. Vous allez voir ce qui fait grimper la facture, ce qui peut passer inaperçu, et comment Twilio se positionne face aux alternatives.

Aperçu des tarifs SMS Twilio

Twilio utilise une tarification à la consommation. Vous payez par segment de message, par numéro de téléphone chaque mois, et pour toute fonctionnalité ou enregistrement optionnel. Aucun contrat ni minimum obligatoire, sauf en cas de remise négociée sur de gros volumes.

Le tarif de base pour les SMS US sur code long est 0,0083 $ par segment pour l'envoi et la réception. Mais ce tarif n'inclut ni les frais d'opérateur, ni la location de numéro, ni les frais de conformité.

Twilio applique également des remises sur volume automatiques à partir de 150 000 messages/mois pour chaque type de numéro – rien à négocier, la remise s’active automatiquement.

Détail de la tarification : SMS, MMS, numéros gratuits et codes courts

SMS via code long (numéros à 10 chiffres)

Les codes longs sont les numéros standards à 10 chiffres utilisés pour la plupart des messageries A2P aux États-Unis.

Type de message	Prix par segment
SMS sortant	0,0083 $
SMS entrant	0,0083 $
MMS sortant	0,022 $
MMS entrant	0,0165 $

À noter : Twilio facture par segment de message, pas par message complet. Un segment = 160 caractères GSM-7. Si vous utilisez Unicode (émojis, accents), un segment = 70 caractères. Par exemple, un message de 200 caractères = 2 segments facturés.

Numéros gratuits

Les numéros gratuits appliquent les mêmes tarifs de base SMS : 0,0083 $ par segment envoyé/reçu. MMS sortant : 0,022 $ ; MMS entrant : 0,02 $. Ces numéros sont adaptés au trafic unidirectionnel à fort volume et ne requièrent pas d’enregistrement 10DLC, mais nécessitent une vérification pour le débit maximal.

Codes courts (numéros à 5-6 chiffres)

Idéaux pour les campagnes à haut débit. Le tarif SMS reste à 0,0083 $ par segment, mais la location du numéro est bien plus élevée.

Type de code court	Coût mensuel
Code court aléatoire	1 000 $/mois (facturé trimestriellement)
Code court personnalisé	1 500 $/mois (facturé trimestriellement)
Code personnalisé apporté	500 $/mois (facturé trimestriellement)

Tous les codes courts compatibles MMS entraînent aussi des frais uniques de 500 $.

Remises sur volume

Twilio applique des remises automatiques pour les SMS par code long, numéro gratuit et code court :

Messages mensuels	Prix par segment
1 à 150 000	0,0083 $
150 001 à 300 000	0,0081 $
300 001 à 500 000	0,0079 $
500 001 à 750 000	0,0077 $
750 001 à 1 000 000	0,0075 $
1 000 001+	0,0073 $

Le volume est calculé par type de numéro. Les volumes ne sont pas cumulables entre codes longs et numéros gratuits.

Ce qui influence votre facture Twilio

Type de numéro de téléphone

Le type de numéro (code long, gratuit, code court) détermine la grille tarifaire et les seuils de remise. Répartir le trafic entre plusieurs types peut empêcher d’atteindre les paliers de remise.

Segments de message

Chaque segment est facturé. Un texte long ou contenant des caractères Unicode multiplie le coût par message.

Frais d'opérateur

Les opérateurs US ajoutent leur propre surtaxe par message, en plus du tarif Twilio. Ces frais sont répercutés directement.

Frais d'opérateur pour les codes longs (SMS sortants) :

Opérateur	Frais d'envoi
AT&T	0,0035 $
T-Mobile	0,0045 $
Verizon	0,004 $
US Cellular	0,005 $
Tous les autres opérateurs	0,004 $

Pour les MMS, ces frais sont plus élevés (AT&T : 0,009 $ par MMS ; T-Mobile : 0,01 $).

Par exemple, un SMS sortant vers AT&T coûte 0,0083 $ (Twilio) + 0,0035 $ (opérateur) = 0,0118 $ par segment.

Pays de destination

Les tarifs internationaux varient fortement. UK : 0,04 $/message ; Inde : 0,0029 $ ; Brésil : 0,075 $. Consultez le CSV des tarifs Twilio pour tous les détails.

Enregistrement 10DLC

Le système 10DLC US oblige les entreprises à enregistrer leur marque et leurs campagnes pour les SMS A2P sur code long. Sans cet enregistrement, le trafic est filtré par les opérateurs.

Coûts et frais cachés

Frais d'enregistrement 10DLC

Depuis août 2025, la tarification a évolué.

Enregistrement de marque :

Marque individuelle ou standard faible volume : 4,50 $ (frais uniques)
Marque standard avec vérification secondaire : 46 $ (frais uniques)

Enregistrement de campagne :

Vérification unique : 15 $ par campagne
Mensuel récurrent : 1,50 $ à 10 $/mois selon le type

Type de campagne	Frais mensuels
Entrepreneur individuel	2 $/mois
Mixte à faible volume	1,50 $/mois
Standard	10 $/mois
Organisation caritative/501(c)(3)	3 $/mois
Services d'urgence	5 $/mois

La vérification standard coûte 41,50 $. Les appels de vérification coûtent 11 $. Toute révision de soumission erronée coûte 12,50 $.

Frais de numéro de téléphone

Chaque numéro a un coût mensuel :

Code long : 1,15 $/mois
Numéro gratuit : 2,15 $/mois

Prévoyez ce coût si vous provisionnez plusieurs numéros.

Frais sur les messages échoués

Twilio facture 0,001 $ par message avec le statut "Échec". Ce coût peut s’accumuler lors de débogages ou de filtrage par opérateur.

Modules complémentaires

Raccourcissement de liens et suivi de clics : 0,015 $ par message sortant après 1 000 gratuits/mois.
Boîte à outils conformité (analyse IA) : 0,015 $ par message sortant.

Plans de support

Le support gratuit est limité. Les plans payants démarrent à 250 $/mois ("Développeur"). Pour une entreprise qui dépend du SMS, prévoyez un plan de support.

Comment Twilio se compare aux alternatives

Fournisseur	SMS sortant US	SMS entrant US	Numéro de téléphone	10DLC requis
Twilio	0,0083 $ + frais d'opérateur	0,0083 $ + frais d'opérateur	1,15 $/mois	Oui
Plivo	0,005 $	0,00035 $	0,80 $/mois	Oui
Telnyx	0,004 $	0,004 $	1,00 $/mois	Oui
Bird (ex-MessageBird)	~0,007 $	~0,007 $	Varie	Oui

Plivo et Telnyx sont plus économiques par message, surtout en réception. Telnyx intègre les frais d’opérateur différemment, ce qui complique la comparaison, mais leur tarif global est souvent inférieur.

Twilio reste leader sur la documentation, la qualité API, l’écosystème et les intégrations. Si vous cherchez une expérience développeur optimale ou des fonctions avancées, le surcoût peut se justifier. Pour l’envoi massif à prix réduit, évaluez Telnyx ou Plivo.

Comment tester Twilio gratuitement

Twilio propose un compte d’essai gratuit sans carte bancaire. Vous obtenez un petit crédit pour envoyer de vrais messages.

Pendant l’essai, les messages à des numéros non vérifiés affichent un préfixe "Envoyé depuis votre compte d’essai Twilio". Pour supprimer ce préfixe, activez un compte payant.

L’essai gratuit permet de :

Provisionner un numéro de test
Envoyer et recevoir des SMS via l’API
Tester la réception de webhooks
Explorer la console Twilio et les logs d’utilisation

Lorsque vous passez en payant, vous ne payez que ce que vous consommez, sans minimum mensuel.

Comment tester votre intégration SMS Twilio avec Apidog

Après configuration des identifiants Twilio et des webhooks, il est crucial de valider votre intégration. L’envoi manuel de messages ne détecte pas les incompatibilités de schéma ou les erreurs de payload.

La fonctionnalité Scénarios de test d’Apidog permet d’automatiser et d’enchaîner plusieurs requêtes API. Vous pouvez :

Importer la spécification OpenAPI de votre webhook Twilio dans un scénario de test
Ajouter des étapes pour chaque flux : envoi SMS, réception de callback, gestion d’une réponse entrante
Orchestrer en séquence via le mode d’orchestration
Transférer des données entre étapes avec la syntaxe {{$.stepId.response.body.field}} (ex : chaîner les SIDs de message)

Exemple de test automatisé Twilio :

{
  "steps": [
    {
      "name": "Envoyer SMS",
      "request": {
        "method": "POST",
        "url": "https://api.twilio.com/2010-04-01/Accounts/{AccountSid}/Messages.json",
        "body": {
          "To": "+1xxxxxxxxxx",
          "From": "+1yyyyyyyyyy",
          "Body": "Message de test"
        }
      }
    },
    {
      "name": "Vérifier callback",
      "request": {
        "method": "POST",
        "url": "https://votre-app.com/webhook",
        "body": {
          "MessageSid": "{{$.Envoyer SMS.response.body.sid}}"
        }
      }
    }
  ]
}

Le Test de Contrat d’Apidog ajoute une vérification automatique des réponses API par rapport à votre OpenAPI :

Statut HTTP conforme à la doc
Champs obligatoires présents dans le webhook
Types corrects pour chaque champ (ex : SID en string)
Aucun champ supplémentaire non défini, sauf si additionalProperties autorisé

Ce workflow s’intègre dans vos pipelines CI/CD, sans scripts d’assertion personnalisés.

Pour démarrer :

Téléchargez Apidog gratuitement
Importez votre spécification d’API Twilio ou définissez votre schéma de webhook
Construisez un scénario de test qui reflète votre flux SMS

Conclusion

La tarification Twilio démarre à 0,0083 $ par segment sur code long US, mais le coût réel inclut les frais d’opérateur, la location de numéro et l’enregistrement 10DLC. Un SMS sortant AT&T revient à environ 0,0118 $ par segment. Pour les campagnes 10DLC standard, ajoutez 10 $/mois/campagne.

La tarification est transparente et bien documentée, avec remises sur volume automatiques. Mais chaque poste compte : ne vous limitez pas au tarif affiché.

Après modélisation de vos coûts, intégrez et testez votre solution. Les scénarios et tests de contrat Apidog valident vos flux webhook Twilio et assurent la conformité à votre spécification, sans code de test répétitif.

FAQ

Q : Quel est le prix de base d'un SMS sortant américain sur Twilio ?

R : 0,0083 $ par segment de message sur code long américain. Des frais d’opérateur s’ajoutent (ex : AT&T +0,0035 $).

Q : Twilio facture-t-il les SMS entrants ?

R : Oui. 0,0083 $ par segment, code long et numéro gratuit. Des frais d’opérateur peuvent s’appliquer selon l’origine.

Q : Qu'est-ce que le 10DLC et dois-je le payer ?

R : 10DLC = système d’enregistrement US pour SMS A2P sur code long. Obligatoire pour les messages d’application à consommateurs US. Enregistrement de marque : 4,50 $ (frais uniques). Frais de campagne : 1,50 $ à 10 $/mois.

Q : Combien coûte un code court Twilio ?

R : Code court aléatoire : 1 000 $/mois (trimestriel). Code court personnalisé : 1 500 $/mois. Frais de config MMS : 500 $. Tarif SMS : 0,0083 $/segment.

Q : Twilio offre-t-il des remises sur volume ?

R : Oui, automatiquement à partir de 150 000 messages/mois par type de numéro. Le tarif baisse par paliers jusqu’à 0,0073 $ pour 1M+ messages/mois. Des remises entreprise sont disponibles.

Q : Y a-t-il un essai gratuit pour Twilio ?

R : Oui. Compte d’essai avec crédits inclus, sans carte bancaire. Les messages sortants incluent un préfixe d’essai jusqu’à activation payante.

Q : Quelle est l’alternative Twilio la moins chère pour les SMS ?

R : Plivo (0,005 $ sortant, 0,00035 $ entrant) et Telnyx (0,004 $/message) sont moins chers. 10DLC requis pour l’A2P US. Twilio se distingue par sa documentation, son support et ses fonctionnalités avancées.

Prix API SMS Vonage : Tarifs 2026

Antoine Laurent — Fri, 03 Apr 2026 03:54:49 +0000

EN BREF

La tarification de l'API SMS Vonage commence à 0,00809 $ par message sortant et à 0,00649 $ par message entrant aux États-Unis. Aucun minimum mensuel : vous payez uniquement ce que vous consommez. Les tarifs internationaux varient selon le pays et peuvent dépasser 1,00 $ sur certains marchés. Pour développer ou tester une intégration SMS Vonage, Apidog simplifie l'envoi de requêtes de test, la validation des réponses et la détection des erreurs avant le déploiement.

Essayez Apidog dès aujourd'hui

Introduction

Si vous avez déjà entendu parler de Nexmo, vous connaissez Vonage. Depuis l'acquisition de Nexmo par Vonage en 2016, la plateforme développeur est accessible via developer.vonage.com. En 2022, Ericsson a intégré Vonage tout en conservant la marque et l’activité API.

Aujourd'hui, Vonage dessert plus de 100 000 entreprises et 1,6 million de développeurs enregistrés. La plateforme propose un modèle à l'usage, sans engagement, avec une couverture mondiale de plus de 190 pays.

💡 Avant d'aller plus loin avec votre intégration, il est crucial de disposer d’un outil de test d’API fiable. Apidog vous permet de créer des scénarios de test pour vos requêtes SMS Vonage, de valider les réponses selon des schémas prédéfinis et d’enchaîner plusieurs appels API dans un seul flux. Essayez Apidog gratuitement. Aucune carte de crédit requise.

Aperçu des tarifs SMS Vonage

Vonage fonctionne en paiement à l'usage : pas de frais de plateforme, pas d'abonnement. Vous payez par message, selon le pays de destination et le type de numéro.

Principaux tarifs aux États-Unis :

Type de message	Prix par message
SMS sortant (LVN américain)	0,00809 $
SMS entrant (LVN américain)	0,00649 $
SMS sortant (numéro gratuit américain)	Contacter le service commercial
SMS entrant (numéro gratuit américain)	Gratuit

LVN = Numéro Virtuel Local (code long à 10 chiffres/10DLC).
Téléchargez la feuille de tarifs mondiale depuis votre tableau de bord Vonage pour planifier vos campagnes internationales.

Ventilation des tarifs : sortant, entrant, MMS et WhatsApp

SMS sortant

Envoyez des SMS depuis votre application vers les utilisateurs finaux. Tarif : 0,00809 $/message depuis un LVN US. Vérifiez toujours le tarif actuel sur le dashboard Vonage.

SMS entrant

Réception sur un numéro Vonage loué : 0,00649 $/message aux US pour les LVN. Les numéros gratuits peuvent recevoir des SMS gratuitement — à vérifier selon votre compte.

Tarification MMS

Les MMS sont pris en charge via l’API Messages. Pas de tarif public : contactez le service commercial pour obtenir les tarifs MMS selon vos marchés.

WhatsApp via Vonage

Vonage permet l'envoi de messages WhatsApp via son API Messages. Deux types de frais :

Frais Meta : Selon la catégorie de conversation (marketing, utilitaire, OTP, service). Consultez la tarification officielle WhatsApp de Meta.
Frais Vonage : À partir de 0,00015 $/message, selon volume et catégorie.

Facebook Messenger

Supporté à 0,0011 $/message livré via l’API Messages.

RCS (Rich Communication Services)

Tarifs RCS aux États-Unis, selon l’opérateur :

Opérateur	RCS Rich (texte)	RCS Rich Media
T-Mobile	0,00620 $	0,01250 $
Verizon	0,00400 $	0,00600 $
AT&T	0,00450 $	0,01000 $
US Cellular	0,00620 $	0,01350 $

Frais de configuration unique de 600 $/pays pour le RCS.

Ce qui affecte votre facture Vonage

Pays de destination

Le coût varie fortement selon le pays. Consultez la feuille de tarifs avant de lancer une campagne internationale.

Type de numéro

Trois types principaux (US) :

Code long (10DLC) : Numéro local standard, idéal P2P/A2P.
Numéro gratuit : Débit élevé, entrant souvent gratuit.
Code court : Pour très gros volumes, nécessite enregistrement.

Chaque type a ses tarifs par message et de location.

Frais de location de numéro

À partir de quelques dollars/mois pour un LVN US. Plus cher pour les numéros gratuits et les codes courts.

Encodage des messages

GSM-7 (standard) : 160 caractères/SMS.
Unicode : 70 caractères/SMS. Les messages plus longs sont facturés comme plusieurs SMS.

Surcoûts des opérateurs

Les opérateurs US appliquent des surcoûts (notamment en 10DLC A2P). Vonage les répercute : surveillez votre facture.

Coûts cachés à surveiller

Niveaux de support

Gratuit : forums/doc.
Commercial : forfait payant.
Premium (24/7 + account manager) : 3 300 $/mois.

API additionnelles

Module complémentaire	Coût mensuel
API d'audit	550 $/mois
Auto-rédaction (PII)	1 100 $/mois
API de rapports	495 $/mois (ou 0,00049 $/CDR à l'usage)

Coûts de l'API Verify

Authentification à deux facteurs : 0,0572 $/vérification réussie + coûts SMS/voix pour chaque tentative.

Enregistrement de numéro (10DLC US)

Enregistrement de marque : frais unique.
Enregistrement de campagne : frais mensuel récurrent.

Obligatoire pour l’envoi A2P via codes longs aux US.

Vonage contre les alternatives

Tarifs SMS sortants/entrants US :

Fournisseur	SMS sortant US	SMS entrant US	Essai gratuit	Support
Vonage	0,00809 $	0,00649 $	Oui (numéros vérifiés uniquement)	Niveaux payants ; 3 300 $/mois pour 24/7
Twilio	0,0079 $	0,0075 $	Oui (crédit 15 $)	Support payant dès 250 $/mois
Plivo	0,0055 $	0,0005 $	Oui	Basique gratuit ; payants
Telnyx	0,004 $	0,002 $	Oui (crédit 5 $)	Email 24/7 gratuit ; téléphone payant

À retenir :

Telnyx = le moins cher, mais plateforme jeune.
Plivo = bons tarifs et réputé chez les développeurs.
Twilio = écosystème et documentation les plus riches.
Vonage = fiable, soutenu par Ericsson, tarifs intermédiaires.

Le prix n'est qu'un critère : prenez aussi en compte la conformité, le support, la fiabilité et la qualité des outils.

Comment essayer Vonage gratuitement

Vonage propose un compte d’essai gratuit.

Ce que vous obtenez

Numéro virtuel Vonage pour tests
Identifiants API (clé + secret)
Accès à la documentation et aux SDK
Crédits de test pour envoyer un nombre limité de messages

Ce qui est restreint

Vous ne pouvez tester qu’avec des numéros que vous avez vérifiés sur votre compte, jusqu’à upgrade vers un compte payant.

Comment commencer

Rendez-vous sur dashboard.nexmo.com ou vonage.com/communications-apis
Créez un compte gratuit avec email
Vérifiez votre numéro de téléphone
Récupérez votre clé API et votre secret dans le dashboard
Effectuez votre premier appel API via REST ou un SDK officiel

SDKs disponibles pour Node.js, Python, PHP, Ruby, Java, .NET, Go, ou utilisez directement l’API REST avec n’importe quel client HTTP.

Comment tester votre intégration SMS Vonage avec Apidog

Après avoir obtenu votre clé API et votre secret Vonage, vous devez valider votre intégration localement avant passage en production. Apidog automatise ces tests.

Configuration d’un scénario de test

Dans Apidog, module Tests :

Importez votre spec API (OpenAPI pour SMS Vonage)
Ajoutez une requête personnalisée vers https://rest.nexmo.com/sms/json
Ou importez une commande cURL depuis la doc Vonage

Exemple de payload POST :

{
  "api_key": "VOTRE_API_KEY",
  "api_secret": "VOTRE_API_SECRET",
  "to": "NUMERO_DESTINATAIRE",
  "from": "NUMERO_EXPEDITEUR",
  "text": "Message de test"
}

Validation de la réponse

Définissez vos assertions dans Apidog :

Code HTTP = 200
messages[0].status == "0"
messages[0].message-id non vide

Toute erreur (status ≠ 0) fait échouer explicitement le test : vous voyez la réponse complète pour le débogage.

Transmission de données entre requêtes

Pour chaîner des tests (ex. envoyer un SMS puis vérifier son statut), utilisez la syntaxe :

{{$.stepId.response.body.field}}

Exemple : extraire message-id d’une réponse et l’utiliser dans une étape suivante.

Exécution des tests en CI/CD

Apidog s’intègre à GitHub Actions, GitLab CI, Jenkins. Exportez votre scénario de test et exécutez-le en CLI pour détecter toute régression d’intégration SMS avant production.

Essayez gratuitement sur apidog.com. Aucune carte de crédit requise.

Conclusion

La tarification SMS Vonage est à l’usage, sans minimum mensuel. SMS sortant US : 0,00809 $/message ; entrant : 0,00649 $. Les coûts varient selon le pays, le type de numéro et l’encodage. Les modules premium (audit, auto-rédaction, support 24/7) ajoutent des frais mensuels : budgétez-les dès le départ.

En alternative, Telnyx et Plivo sont moins chers, Twilio domine en intégrations. Vonage combine fiabilité et couverture internationale grâce à Ericsson.

Avant production, créez des scénarios de test Apidog pour valider chaque flux Vonage. Testez, validez, détectez les erreurs avant la mise en ligne.

FAQ

Vonage est-il identique à Nexmo ?

Oui. Vonage a acquis Nexmo en 2016. La plateforme développeur reste accessible via developer.vonage.com, et beaucoup d'intégrations utilisent encore rest.nexmo.com comme endpoint API.

Vonage facture-t-il des frais mensuels pour les SMS ?

Non : pas de frais mensuels pour l’API SMS elle-même. Vous payez à l’usage et pour la location de numéro. Les modules complémentaires (audit, auto-rédaction) sont facturés mensuellement.

Combien coûte un numéro de téléphone Vonage ?

Numéro local US : quelques dollars/mois. Numéro gratuit ou code court : plus cher. Consultez le dashboard pour les tarifs à jour.

Quels pays sont pris en charge par les SMS Vonage ?

Plus de 190 pays. Tarifs très variables : certains marchés >0,50 $/message. Téléchargez la feuille de tarifs mondiale pour le détail.

Vonage offre-t-il des réductions de volume ?

Oui, pour les gros volumes. Contactez le service commercial pour un tarif personnalisé. Le tarif à l'usage s'applique par défaut.

Puis-je recevoir des SMS entrants gratuitement ?

Souvent gratuit pour les numéros gratuits US. LVN US : 0,00649 $/message entrant. Consultez la tarification selon votre pays.

Comment Vonage se compare-t-il à Twilio pour les SMS ?

Vonage (0,00809 $) est légèrement plus cher que Twilio (0,0079 $) pour le SMS sortant US. Twilio a plus d’intégrations et un plus grand écosystème. Vonage se distingue par la fiabilité réseau (Ericsson) et ses tarifs internationaux compétitifs. Pour l’A2P pur US, la différence est minime : l’expérience développeur et le support feront souvent la différence.

Cursor 3 : Implications pour les développeurs d'API

Antoine Laurent — Fri, 03 Apr 2026 03:50:31 +0000

TL;DR : Cursor 3, lancé le 2 avril 2026, remplace l’interface centrée IDE par un espace de travail piloté par agents. Pour les développeurs d’API, les nouveautés clés sont l’exécution parallèle d’agents, des sorties d’outils MCP enrichies, et un transfert cloud/local sans interruption de workflow. Connecté au serveur MCP d’Apidog, vos agents IA peuvent lire la spécification API en direct et générer du code conforme, sans copier-coller.

Essayez Apidog dès aujourd'hui

Le changement attendu : agents au centre

Les éditeurs de code IA ont progressé, mais Cursor 3 n’est pas une simple mise à jour. Il redéfinit l’environnement de développement IA.

Avant Cursor 3 : vous utilisiez l’IDE classique, faisiez appel à un agent ponctuellement, puis repreniez la main sur le code. Les agents étaient des assistants optionnels.

Avec Cursor 3 : les agents deviennent l’unité de travail principale. Gérez-les comme des onglets de navigateur, lancez-les en parallèle, vérifiez leurs résultats, et promouvez le meilleur.

Pour les développeurs d’API, c’est particulièrement pertinent. Les tâches d’API exigent coordination et parallélisme : endpoints, tests de contrat, documentation, gestion des schémas. Cursor 3 permet de gérer ces tâches comme elles se produisent en réalité.

💡Cursor 3 ne connaît pas votre spécification API par défaut. Connectez le serveur MCP d'Apidog pour permettre à vos agents d’extraire vos schémas OpenAPI, définitions de endpoints, et scénarios de test directement depuis Apidog. Résultat : moins d’hallucinations, du code généré conforme.

Cet article détaille les évolutions majeures de Cursor 3 pour le développement d’API, et propose un workflow concret liant Cursor 3 au serveur MCP d’Apidog.

Quoi de neuf dans Cursor 3

Cursor 3 introduit la Fenêtre des Agents, mais aussi plusieurs fonctionnalités clés pour les développeurs d’API.

Fenêtre des Agents

La Fenêtre des Agents remplace l’éditeur comme centre du workflow. Lancez des agents sur plusieurs dépôts (local, worktree git, cloud Cursor, SSH distant) en parallèle.

Accès rapide : Cmd+Shift+P -> Agents Window. L’IDE reste disponible à côté si besoin.

Cas d’utilisation : lancez un agent pour scaffolder un endpoint, pendant qu’un autre corrige un bug ailleurs. Observez, intervenez, validez les diffs.

Mode Conception

Dans la Fenêtre des Agents, le Mode Conception permet d’annoter l’interface web directement. Sélectionnez, surlignez des éléments, ajoutez-les au contexte d’agent sans écrire de descriptions.

Cmd+Shift+D pour basculer
Shift+glisser pour sélectionner une zone
Cmd+L pour ajouter au chat

Applications MCP : sorties structurées

Les applications MCP supportent désormais les sorties structurées. Avant, les retours d’outils étaient du texte ; maintenant, ils peuvent renvoyer des données typées.

Pour le serveur MCP d’Apidog, cela signifie que les définitions de endpoints, schémas, résultats de test sont accessibles dans un format exploitable par les agents Cursor. Moins d’ambiguïtés.

Worktrees, /best-of-n et isolation

/worktree : crée un worktree git isolé. Testez des modifications sans impacter la branche principale.
/best-of-n : exécute une tâche sur plusieurs modèles (Claude, GPT-4o, Gemini, etc.) en parallèle, chacun dans son worktree. Comparez, sélectionnez le meilleur résultat.

Exemple : implémenter un endpoint complexe, comparer trois solutions générées.

Transfert cloud/local

Lancez une tâche longue dans le cloud Cursor, puis rapatriez-la localement pour tester sur vos services. Ou poussez une session dans le cloud avant de fermer votre session. Flexibilité totale.

Impact sur le développement d’API : workflows pratiques

Le développement d’API implique beaucoup de changements de contexte : spécification, client API (Apidog), éditeur, terminal, docs. Cursor 3 améliore la coordination et le parallélisme côté agents, mais le vrai gain vient de la couche MCP connectée à vos outils.

Développement parallèle d’endpoints

Plus besoin d’échafauder vos endpoints un par un. Décrivez chaque endpoint à une instance d’agent distincte, laissez-les travailler en parallèle, puis révisez et fusionnez les meilleures solutions.

Génération de code sensible au schéma

Sans accès à la spécification OpenAPI, l’agent devine la structure. Avec le serveur MCP d’Apidog, l’agent extrait la structure réelle : champs, types, énumérations, objets imbriqués. Moins de corrections manuelles.

Test de contrat dans l’éditeur

Les agents Cursor 3 peuvent exécuter la CLI Apidog dans leur workflow :

apidog run --scenario <test-id>

Décrivez le comportement, l’agent génère l’implémentation, exécute les tests, itère automatiquement en cas d’échec. Vous supervisez.

Documentation synchronisée

Les agents Cursor 3 peuvent lire la documentation Apidog via MCP et comparer la spéc avec le code. Ils signalent les divergences pour action immédiate.

⚠️ Nécessite une configuration initiale, mais les fondations sont là pour garder doc et code alignés.

Ce qui ne change pas

Cursor 3 ne remplace pas vos outils de test avancés : pas de détection automatique d’erreurs d’auth, ou de test de montée en charge. La qualité des sorties MCP dépend aussi du serveur utilisé : le serveur MCP d’Apidog gère le contenu structuré, d’autres non.

Workflow concret : Cursor 3 + Serveur MCP Apidog

Voici comment utiliser Cursor 3 avec le serveur MCP d’Apidog pour automatiser vos tâches API.

Configuration

Ajoutez le serveur MCP Apidog dans Cursor :

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_access_token"
      }
    }
  }
}

Récupérez votre token dans Apidog > Paramètres du compte > Jeton d’accès API. Les agents Cursor peuvent alors appeler des outils MCP comme get_endpoint_detail, list_endpoints, etc.

Exemple : scaffolder un endpoint depuis la spécification

Supposons que vous ajoutiez POST /invoices à votre spéc Apidog. Dans la Fenêtre des Agents, lancez une session :

"Recherchez l’endpoint POST /invoices dans le projet Apidog. Lisez ses schémas de requête et de réponse. Générez un handler Node.js/Express conforme. Puis exécutez le scénario de test associé."

L’agent va :

Appeler get_endpoint_detail via MCP.
Générer le code selon le schéma réel.

Exécuter :

apidog run --scenario invoice-creation-test --env staging

Corriger si les assertions échouent.

Vous validez le diff final.

/best-of-n pour endpoints complexes

Pour un endpoint compliqué, utilisez /best-of-n : trois agents génèrent chacun une version, tous lisant la même spéc Apidog via MCP. Comparez les branches worktree, gardez la meilleure.

Garder la documentation à jour

Après déploiement :

"Vérifiez la documentation Apidog pour POST /invoices. Comparez-la au code dans invoices.js. Signalez toute divergence. Si besoin, mettez à jour la spéc Apidog."

L’agent lit les deux via MCP, propose des corrections. La synchronisation doc/code devient une étape du cycle de revue.

Démarrage rapide : configuration étape par étape

Étape 1 : Mettre à niveau Cursor

Téléchargez la dernière version sur cursor.com. Vérifiez Agents Window dans la palette de commandes (Cmd+Shift+P).

Étape 2 : Générer un jeton d’accès Apidog

Connectez-vous à Apidog. Générer un nouveau jeton (Paramètres du compte > Jeton d’accès API). Copiez-le.

Étape 3 : Ajouter le serveur MCP Apidog à Cursor

Dans Paramètres Cursor > MCP :

{
  "mcpServers": {
    "apidog": {
      "command": "npx",
      "args": ["-y", "@apidog/mcp-server@latest"],
      "env": {
        "APIDOG_ACCESS_TOKEN": "your_token_here",
        "APIDOG_PROJECT_ID": "your_project_id"
      }
    }
  }
}

L’ID projet est dans l’URL Apidog. Sauvegardez, redémarrez Cursor.

Étape 4 : Vérifier la connexion

Dans la Fenêtre des Agents :

Tapez « Listez les endpoints de mon projet Apidog. »

L’agent doit afficher vos endpoints : c’est prêt.

Étape 5 : Installer et configurer la CLI Apidog

npm install -g apidog-cli
apidog -v

Depuis Apidog, ouvrez un scénario de test, onglet CI/CD : copiez la commande CLI générée. Exécutez-la dans le terminal intégré Cursor, ou demandez à un agent de le faire.

Étape 6 : Exécuter votre première tâche agent/MCP

Dans la Fenêtre des Agents :

"Recherchez le schéma de l’objet Utilisateur dans Apidog. Générez une interface TypeScript qui y correspond exactement."

Comparez le résultat à la spécification réelle.

À partir de là, automatisez : lecture de spéc, génération de code, exécution de tests, le tout dans une session d’agent.

Pour conclure

Cursor 3 fait passer le développement IA d’un workflow centré éditeur à une orchestration par agents, en phase avec la réalité du développement d’API moderne : endpoints multiples, services variés, environnements parallèles.

La sortie structurée MCP, peu visible dans le changelog, est un atout majeur pour les développeurs d’API. Avec des données propres issues d'Apidog, vos agents Cursor génèrent du code plus fiable, avec moins de corrections et d’itérations.

Associer Cursor 3 au serveur MCP et à la CLI Apidog, c’est obtenir un agent IA qui connaît réellement votre API, lit la spécification, génère le code adéquat, et exécute les tests pour vérifier. Ce n’est pas une démo : c’est un workflow exploitable au quotidien.

Foire aux questions

Est-ce que Cursor 3 remplace l’interface IDE existante ?

Non. La Fenêtre des Agents est une nouvelle interface. L’IDE reste accessible à tout moment.

Différence clé entre Cursor 3 et l’ancienne version ?

Cursor 3 est centré sur les agents : exécution parallèle, transfert cloud/local, Mode Conception, /worktree, /best-of-n. L’éditeur reste disponible en complément.

Connexion du serveur MCP Apidog à Cursor 3 ?

Ajoutez la configuration MCP dans les paramètres Cursor. Le serveur expose endpoints, schémas et scénarios Apidog comme outils utilisables par les agents. Le support du contenu structuré permet à Cursor de recevoir des données typées.

Exécution automatique de scénarios de test Apidog par les agents Cursor 3 ?

Oui, via la CLI : les agents peuvent exécuter des commandes terminal, lire les sorties, et ajuster le code en fonction des résultats de test. Boucle code/validation resserrée.

Faut-il un abonnement payant à Cursor pour utiliser la Fenêtre des Agents ?

La Fenêtre des Agents est incluse pour tous les forfaits. L’exécution cloud (agents actifs hors ligne) requiert un abonnement payant. Les agents locaux fonctionnent en gratuit. Voir cursor.com/pricing pour les détails.

Comment exécuter Gemma 4 comme API Backend ?

Antoine Laurent — Fri, 03 Apr 2026 02:43:05 +0000

En bref :

Google a lancé Gemma 4 en avril 2026, une famille de quatre modèles ouverts sous licence Apache 2.0 qui surpasse des modèles 20 fois plus grands sur les benchmarks standards. Vous pouvez appeler l'API Gemma 4 via Google AI Studio, Vertex AI, ou l'exécuter localement avec Ollama et vLLM. Associez-le à Smart Mock d'Apidog pour générer automatiquement des réponses API réalistes à partir de vos schémas OpenAPI sans écrire une seule règle de mock.

Essayez Apidog dès aujourd'hui

Introduction

La plupart des modèles d'IA open-source vous obligent à choisir : capacité brute ou déployabilité. Soit vous obtenez un modèle trop grand pour fonctionner sur votre ordinateur portable, soit un petit modèle qui ne peut pas gérer le raisonnement en plusieurs étapes. Gemma 4 brise ce compromis.

Gemma 4 est la famille de modèles ouverts la plus performante de Google DeepMind à ce jour. Le modèle 31B Dense se classe 3e parmi tous les modèles ouverts sur le classement d'Arena AI, battant des concurrents 20 fois plus grands. Le 26B Mixture of Experts (MoE) occupe la 6e place. Les deux fonctionnent sur un seul GPU de 80 Go. Les modèles légers E2B et E4B fonctionnent complètement hors ligne sur les téléphones et les appareils périphériques.

Pour les développeurs d'API, cela est plus important qu'il n'y paraît. Gemma 4 prend en charge nativement l'appel de fonctions, la sortie JSON structurée et des fenêtres de contexte de 256K. Cela en fait un choix pratique pour construire des outils d'API basés sur l'IA, de la génération de données de test à l'écriture de mocks en passant par l'analyse des réponses API.

💡Si vous développez avec Gemma 4 et avez besoin de valider ces réponses générées par l'IA par rapport à votre spécification OpenAPI, le moteur Smart Mock d'Apidog peut générer automatiquement des réponses de mock conformes au schéma à partir de votre définition d'API. Vous n'avez pas besoin d'écrire des règles de mock individuelles ; Smart Mock lit votre schéma et produit instantanément des données contextuellement appropriées. Téléchargez Apidog gratuitement et connectez-le à votre flux de travail d'API Gemma 4.

Qu'est-ce que Gemma 4 et quoi de neuf

Gemma 4 est la quatrième génération de modèles de langage ouverts de Google DeepMind. Le nom « Gemma » vient du latin pour pierre précieuse. Depuis début 2024, les modèles Gemma ont été téléchargés plus de 400 millions de fois et la communauté a construit plus de 100 000 variantes.

Gemma 4 est lancé sous une licence Apache 2.0, un changement crucial pour l'usage et la distribution commerciale.

L'innovation majeure de Gemma 4 est l’« intelligence par paramètre » : le modèle 31B Dense offre des performances proches de GPT-4 ou Claude 3 Sonnet à une fraction du coût de calcul, surclassant même des modèles de plus de 600B de paramètres sur Arena AI.

Nouveautés principales par rapport à Gemma 3 :

Entrée multimodale native. Traitement natif des images et vidéos (E2B/E4B ajoutent l’audio pour la reconnaissance vocale).
Fenêtres de contexte étendues. Jusqu’à 256K tokens sur les modèles 26B/31B.
Support agents & appel de fonctions natif. Sortie JSON structurée et instructions système incluses.
Raisonnement avancé. 31B excelle en mathématiques et instructions multi-étapes, utile pour la génération de tests d’API.
Support multilingue natif (140+ langues).
Licence Apache 2.0 pour une exploitation commerciale sans friction juridique.

Variantes et capacités des modèles Gemma 4

Modèle	Paramètres	Paramètres actifs (inférence)	Contexte	Idéal pour
E2B	2B effectifs	~2B	128K	Mobile, IoT, périphérie hors ligne
E4B	4B effectifs	~4B	128K	Téléphones, Raspberry Pi, Jetson Orin
26B MoE	26B au total	~3.8B actifs	256K	Tâches serveur sensibles à la latence
31B Dense	31B	31B	256K	Qualité maximale, recherche, affinage

Les modèles E2B/E4B utilisent une architecture Mixture of Experts pour optimiser la consommation de ressources sur appareils contraints. Le 26B MoE active 3.8B paramètres à l’inférence : idéal pour le serveur à faible latence. Le 31B Dense est dédié à la qualité maximale, notamment pour la génération de réponses API complexes ou l’affinage domaine-spécifique.

Pour un usage API, privilégiez le 26B MoE pour l’équilibre vitesse/qualité, ou le 31B Dense pour la génération de JSON structuré. Tous supportent l'appel de fonctions et la sortie JSON native.

Configuration de l'API Gemma 4 : étape par étape

Trois méthodes pour utiliser Gemma 4 selon vos besoins :

Option 1 : Google AI Studio (prototypage rapide)

Créez un compte sur Google AI Studio et générez une clé API.
Installez le SDK Python :
```
pip install google-genai
```

Premier appel simple :

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemma-4-31b-it")

response = model.generate_content(
    "Generate a JSON object for a user account with id, email, and created_at fields."
)

print(response.text)

Pour forcer une sortie JSON structurée :

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = """
Generate 3 sample user objects for an e-commerce API. 
Each user should have: id (integer), email (string), username (string), 
created_at (ISO 8601 timestamp), and subscription_tier (free|pro|enterprise).
Return as a JSON array.
"""

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

Option 2 : Déploiement local avec Ollama

Exécutez Gemma 4 localement :

Installez Ollama depuis ollama.com.
Téléchargez le modèle :
```
ollama pull gemma4
```
Démarrez le serveur :
```
ollama serve
```

Appel via API OpenAI-compatible :

import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "Generate a valid JSON response for a REST API /products endpoint. Include id, name, price, and stock fields."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

Option 3 : Appel de fonction pour l'orchestration d’API

Utilisez l'appel de fonctions natif pour orchestrer des pipelines automatisés :

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "Retrieve the OpenAPI schema for a given endpoint path",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "The API endpoint path, e.g. /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)

response = model.generate_content(
    "I need to test the GET /users/{id} endpoint. What schema should the response follow?"
)

if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"Model called function: {fc.name}")
    print(f"With args: {dict(fc.args)}")

Ce schéma permet d’intégrer Gemma 4 dans des pipelines de test d’API automatisés.

Construire des mocks d'API basés sur l'IA avec Gemma 4

Pour générer des données de mock à partir d’un schéma OpenAPI :

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
Generate 5 realistic mock responses for an order management API.
Each response must conform exactly to this JSON Schema:
{json.dumps(schema, indent=2)}

Make the data realistic: use realistic prices, product IDs, and varied statuses.
Return as a JSON array of 5 order objects.
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))

Gemma 4 comprend et respecte les contraintes de votre schéma JSON : énumérations, motifs, plages de valeurs, etc. Pour aller plus loin, vous pouvez fournir le schéma complet de votre endpoint ou l’ensemble de votre spec OpenAPI pour générer des mocks sur plusieurs endpoints.

Workflow recommandé : exportez votre collection Apidog comme spéc OpenAPI, collez-la dans le prompt, et demandez à Gemma 4 de générer 10 cas de test réalistes par endpoint. Vous obtenez un jeu de mock complet en quelques secondes.

Tester les réponses de l'API Gemma 4 avec Apidog

Pour valider automatiquement les réponses générées par Gemma 4 :

Étape 1 : Importez votre endpoint d'API Gemma 4 dans Apidog.

Définissez l’URL (Google AI Studio ou wrapper custom) et le schéma de réponse attendu.

Étape 2 : Utilisez Smart Mock d'Apidog pour générer des réponses de référence directement depuis le schéma.

Smart Mock infère des données réalistes selon les noms et types de champs (par exemple, un champ email reçoit une adresse e-mail valide).

Étape 3 : Créez un Scénario de Test dans Apidog.

Ajoutez l’appel API Gemma 4, puis des assertions pour vérifier la réponse.

Exemple de scénario :

Authentification (obtenir un token)
Appel à Gemma 4 avec ce token
Extraction du JSON généré
Validation du JSON selon le schéma
Passage du résultat à un endpoint POST suivant

Étape 4 : Ajoutez vos assertions (codes statut, headers, structure JSON).

Utilisez le processeur d’extraction de variable pour réutiliser la sortie Gemma 4 dans les étapes suivantes.

Étape 5 : Exécutez en mode Data-driven.

Importez un CSV/JSON de jeux de données, lancez 50 variations de tests d'un clic.

Le setup complet prend 15 minutes et s’automatise via la CLI Apidog dans un pipeline CI/CD.

Cas d'utilisation concrets

Génération de données de test API. Générez des centaines de fixtures réalistes via le schéma OpenAPI et le mode JSON natif de Gemma 4.
Mocking API intelligent. Réponses dynamiques selon la requête, sans coder chaque cas à la main.
Génération de documentation API. Gemma 4 peut lire l’intégralité d’une base code ou d’une spec pour produire la documentation OpenAPI manquante.
Validation du schéma de réponse. Analysez les réponses d’API tierces pour détecter les écarts de schéma.
Écriture automatisée de tests de régression. Donnez à Gemma 4 vos specs et rapports de bugs, il génère des cas de test avancés.

Gemma 4 vs autres modèles ouverts pour l'utilisation d'API

Modèle	Paramètres	Contexte	Sortie JSON	Appel de fonction	Licence
Gemma 4 31B	31B	256K	Natif	Natif	Apache 2.0
Gemma 4 26B MoE	26B (3.8B actifs)	256K	Natif	Natif	Apache 2.0
Llama 3.3 70B	70B	128K	Via requête	Via requête	Communauté
Mistral 7B	7B	32K	Via requête	Limité	Apache 2.0
Qwen 2.5 72B	72B	128K	Natif	Natif	Apache 2.0

Pour l’outillage API, les critères essentiels sont : sortie JSON native, appel de fonction, longueur du contexte, et licence claire. Gemma 4 coche toutes les cases avec une efficacité GPU supérieure à Llama et un coût d’infrastructure plus bas.

Conclusion

Gemma 4 est une solution ouverte puissante pour automatiser la génération et la validation de réponses API. Licence Apache 2.0, appel de fonctions natif, sortie JSON structurée : adoptez-le pour vos outils API modernes.

Associez Gemma 4 à Apidog pour un workflow complet :

Génération de données de test et de mocks avec Gemma 4
Prototypage de schémas et mocks via Smart Mock
Validation automatisée via les Scénarios de Test Apidog

Facile à mettre en place, et prêt pour l’intégration CI/CD. Passez à l’action sur vos API dès aujourd’hui.

FAQ

Qu'est-ce que Gemma 4 ?

Gemma 4 est la dernière famille de modèles de langage ouverts de Google DeepMind, lancée en avril 2026. Elle est disponible en quatre tailles (E2B, E4B, 26B MoE, 31B Dense) et est sous licence Apache 2.0. Le modèle 31B se classe actuellement 3e parmi tous les modèles ouverts sur le classement de texte d'Arena AI.

Est-ce que Gemma 4 est gratuit ?

Les poids du modèle sont téléchargeables et utilisables gratuitement sous la licence Apache 2.0. Vous payez pour le calcul lorsque vous l'exécutez vous-même. Si vous utilisez Google AI Studio, il existe un niveau gratuit avec des limites de débit. Vertex AI facture les tarifs de calcul standard de Google Cloud.

Gemma 4 peut-il produire du JSON structuré ?

Oui. Gemma 4 prend en charge un paramètre natif response_mime_type: "application/json" via le SDK Google Generative AI. Cela force le modèle à renvoyer du JSON valide à chaque fois, ce qui est essentiel pour les intégrations d'API où vous analysez la sortie par programmation.

Comment Gemma 4 se compare-t-il à GPT-4o pour le développement d'API ?

GPT-4o est un modèle propriétaire sans option de déploiement local et avec des coûts d'API plus élevés. Gemma 4 31B est gratuit à déployer localement, et ses scores de benchmark sont compétitifs avec GPT-4o sur les tâches de raisonnement. Pour les équipes qui ont besoin de confidentialité des données ou de contrôle des coûts, Gemma 4 mérite une évaluation sérieuse.

Puis-je affiner Gemma 4 avec mes propres données d'API ?

Oui. Google prend en charge l'affinage de Gemma 4 via Google AI Studio, Vertex AI et des outils tiers comme Hugging Face TRL. L'affinage sur des schémas d'API spécifiques à un domaine et des modèles de réponse peut améliorer considérablement la qualité de la sortie pour des cas d'utilisation spécialisés.

Quel matériel est nécessaire pour exécuter Gemma 4 localement ?

Les modèles 31B et 26B tiennent sur un seul NVIDIA H100 de 80 Go en bfloat16. Les versions quantifiées fonctionnent sur des GPU grand public avec 16 à 24 Go de VRAM. Les modèles E4B et E2B fonctionnent sur les téléphones et les appareils périphériques, y compris Raspberry Pi et NVIDIA Jetson.

Gemma 4 prend-il en charge l'appel de fonctions ?

Oui, tous les modèles Gemma 4 prennent en charge l'appel de fonctions natif. Vous définissez des outils comme des objets JSON avec un nom, une description et un schéma de paramètres. Le modèle décide quand appeler un outil et transmet des arguments structurés sur lesquels vous pouvez agir dans le code.

Comment tester automatiquement les réponses de l'API Gemma 4 ?

Utilisez les Scénarios de Test d'Apidog pour construire un flux de travail de test en chaîne. Importez votre endpoint d'API Gemma 4, configurez les étapes de requête et ajoutez des assertions pour valider la structure de la réponse. Vous pouvez exécuter le scénario localement, via la CLI, ou automatiquement dans votre pipeline CI/CD à chaque push de code.