Qu'est-ce que l'UCP et comment le vérifier ?

L'UCP — le protocole universel de commerce (Universal Commerce Protocol) — est le standard ouvert qui permet à un assistant IA d'acheter pour le compte d'une boutique. Une boutique publie un petit profil lisible par machine à l'adresse /.well-known/ucp, et tout assistant qui parle le protocole peut le lire pour savoir quelle version la boutique parle, comment atteindre son catalogue et son paiement, et quels gestionnaires de paiement elle accepte — sans intégration sur mesure par boutique, sans scraping d'écran, sans deviner. C'est le même problème que llms.txt résout pour le contenu, appliqué au commerce : un humain lit une vitrine, mais un agent a besoin d'un manifeste. Vous pouvez coller n'importe quelle boutique dans le vérificateur UCP et lire son profil comme un verdict — accessible, bien formé, à jour, ou pas UCP du tout — mais cet article vous apprend à lire le document vous-même, pour que la prochaine fois qu'un profil échoue, vous voyiez pourquoi dans le texte.

Ce qu'est l'UCP — et pourquoi les assistants IA en ont besoin

L'UCP est un standard ouvert de Google, codéveloppé avec Shopify, qui donne aux assistants IA un langage commun pour acheter : découvrir une boutique, chercher dans son catalogue, constituer un panier, payer, puis suivre la commande. L'assistant parle à la boutique à travers le protocole au lieu d'une intégration sur mesure, et le commerçant reste le marchand officiel — il conserve ses données clients et ses relations, comme le dit le propre guide de Google. L'intérêt du standard est de réduire un problème d'intégration N par N : sans lui, chaque assistant aurait besoin d'un accord distinct avec chaque commerçant ; avec lui, chaque partie implémente une fois et elles interopèrent.

Le besoin est nouveau parce que la surface d'achat est nouvelle. Les assistants rencontrent désormais les acheteurs dans AI Mode de la recherche Google et dans l'application Gemini, où une question peut devenir un achat sans jamais ouvrir l'onglet d'une boutique. Une fenêtre de chat ne peut pas cliquer sur « ajouter au panier », donc l'assistant a besoin d'un moyen de demander à la boutique, en termes de machine, ce qu'elle vend, comment l'acheter, et ce qui se passe après la vente. L'UCP est ce moyen : il couvre tout le parcours, de la découverte au paiement puis à l'après-vente — commandes, exécution, remises — et il est conçu pour interopérer avec les standards voisins de transport (MCP, A2A) et de preuve de paiement (AP2), plutôt que de les remplacer.

Le fichier de découverte : /.well-known/ucp et ses trois champs obligatoires

Tout le protocole commence par un seul fichier. Une entreprise publie son profil — un objet JSON avec un membre ucp obligatoire — à l'adresse /.well-known/ucp, et une plateforme le télécharge avant de faire quoi que ce soit d'autre. Dans ucp, trois champs sont obligatoires : version, la version du protocole sous forme de date ; services, les surfaces d'API que l'entreprise offre, identifiées par nom de domaine inversé comme dev.ucp.shopping, chaque entrée associant le service à une liaison de transport (REST, MCP, A2A ou embedded) et à un endpoint ; et payment_handlers, les moyens de paiement qu'elle accepte. Les deux derniers doivent être présents même lorsqu'ils sont vides — un objet vide est une affirmation valide (« nous n'offrons pas encore de services »), un champ manquant est un profil cassé. Un quatrième membre, capabilities, est facultatif mais c'est lui qui rend un profil utile : il énumère les fonctionnalités individuelles — paiement, panier, commande, recherche de catalogue — chacune avec sa propre version, ses URLs de spec et de schéma.

Le fichier a aussi des règles d'hébergement, et elles sont strictes pour une raison. Les profils publiés doivent être servis en HTTPS, ne doivent pas rediriger, et doivent porter Cache-Control: public avec un max-age d'au moins 60 secondes — jamais private, no-store ni no-cache. Un profil est l'identité stable et la liste des capacités d'une boutique, pas une réponse par transaction, donc il est fait pour être mis en cache et téléchargé à bas coût ; une redirection ou une directive no-cache dit à une plateforme que l'éditeur n'a pas configuré le document comme le manifeste stable que le protocole attend. Les plateformes annoncent leur propre profil dans l'autre sens, dans l'en-tête de requête UCP-Agent, ce qui rend possible l'intégration sans permission : toute plateforme avec un profil découvrable peut parler à toute entreprise qui en a un, sans inscription préalable.

Lire un vrai document à la main : Allbirds

Les boutiques Shopify publient un profil UCP par défaut, donc chacune d'elles est un exemple en direct — prenons Allbirds, téléchargé le 21 novembre 2026. Son ucp.version est "2026-08-25", la version actuelle, et un objet supported_versions associe deux anciennes versions — 2026-04-08 et 2026-01-23 — à des URLs de profil versionnées sur son domaine myshopify.com, pour que les anciens clients puissent encore négocier. Sous services, dev.ucp.shopping apparaît deux fois : une fois avec le transport mcp à /api/ucp/mcp et une fois avec le transport embedded — et notez ce qui est absent : il n'y a pas d'entrée rest. Une boutique n'a pas à offrir tous les transports ; elle annonce ceux qu'elle exploite réellement. Un second service, dev.ucp.common, est également offert via MCP.

L'objet capabilities est l'endroit où le document devient précis. Allbirds annonce dev.ucp.shopping.checkout, cart, order, catalog.search et catalog.lookup, plus des extensions : fulfillment et discount, qui déclarent toutes deux étendre checkout et cart, ainsi que buyer_consent, identity_linking et une capacité permalink. Les noms sont en domaine inversé par conception : les noms dev.ucp.* sont gouvernés par l'organisme UCP, tandis que les entrées dev.shopify.* — ici dev.shopify.catalog et l'extension dev.shopify.shopping.declared_fields — appartiennent à Shopify. Sous payment_handlers se trouvent trois gestionnaires : com.google.pay, dev.shopify.card et dev.shopify.shop_pay, chacun avec sa version, sa spec et son schéma. Une chose manque, et son absence est normale : le document ne porte pas de tableau keys de niveau supérieur. Les clés de signature sont facultatives — un profil ne les publie que lorsque la boutique signe des requêtes — donc un profil sans clés n'est pas un profil cassé.

Les versions sont des dates — et 2026-08-25 a cassé des choses

Les versions UCP sont des dates de calendrier au format YYYY-MM-DD, et la spécification est catégorique : une entreprise ne doit pas annoncer dans son profil une chaîne de version qui ne soit pas une date, comme "draft". La version actuelle est 2026-08-25 ; les versions antérieures survivent via supported_versions, chacune pointant vers un profil feuille complet et autonome pour cette date. La compatibilité s'établit par égalité exacte de version, et non par « plus récent, mieux » : une plateforme et une entreprise croisent les versions qu'elles supportent toutes les deux, et s'il n'y a pas de version commune, l'entreprise doit répondre version_unsupported. Il y a un autre piège à connaître : chaque entrée de service, de capacité et d'extension dev.ucp.* dans un profil doit déclarer la même version que le ucp.version du profil, et une plateforme qui rencontre une entrée dont la version diffère doit rejeter cette entrée purement et simplement, en la traitant comme absente.

C'est pourquoi une ancienne version reçoit un avertissement plutôt qu'une réussite. La version 2026-08-25 a été le plus grand changement structurel du protocole : elle a supprimé l'ancien champ signing_keys[] du schéma du profil et fait du tableau keys[] de niveau supérieur — un JWK Set — le seul emplacement canonique pour les clés de signature, de sorte qu'un client construit pour la nouvelle version et qui lit signing_keys ne trouve rien ; elle a déplacé les extensions de paiement de l'espace de noms dev.ucp.shopping.* vers dev.ucp.common.payment.* ; elle a restructuré le consentement de l'acheteur, de drapeaux booléens fixes à une carte dynamique ; et elle a consolidé la configuration d'exécution. Une boutique encore en 2026-04-08 continue de fonctionner pour les clients qui parlent 2026-04-08 — c'est exactement à cela que sert supported_versions — mais un assistant qui ne parle que la nouvelle version ne trouvera pas de version mutuellement supportée, et tout outil qui repose sur les anciens noms ou champs passera silencieusement à côté. Ancien, en UCP, signifie « figé dans le temps », pas « cassé » — et l'avertissement est la différence.

UCP contre ACP, AP2 et x402

ACP — le protocole de commerce agentique (Agentic Commerce Protocol), codéveloppé par OpenAI et Stripe — couvre l'étape du paiement à l'intérieur d'une surface de chat comme ChatGPT : l'acheteur approuve l'achat dans la conversation, et l'entreprise encaisse via son propre prestataire de paiement. Sa portée est celle du paiement, pas celle d'un parcours d'achat complet : il répond à la question de savoir comment l'acheteur paie dans le chat, et laisse la découverte du catalogue et l'après-vente à autre chose. Voyez-le comme le parallèle de l'UCP sur les surfaces d'OpenAI, où l'UCP est l'équivalent sur celles de Google.

AP2 — le protocole de paiement des agents (Agent Payments Protocol), publié par Google — répond à une autre question : non pas comment fonctionne le paiement, mais ce que l'utilisateur a réellement autorisé. Il produit des mandats signés et vérifiables — un mandat de paiement pour l'achat lui-même et un mandat de paiement pour le côté paiement — pour qu'un commerçant, un réseau et un émetteur puissent vérifier la même preuve au lieu de croire l'agent sur parole. Il est conçu pour fonctionner aux côtés de l'UCP, en fournissant l'autorisation signée à l'intérieur d'un flux UCP, plutôt que pour le concurrencer.

x402 — créé par Coinbase — répond à une troisième question : comment un agent paie-t-il pour une seule chose, une fois, sans compte et sans page de paiement ? Il ressuscite le code de statut HTTP endormi 402 Payment Required : l'agent demande une ressource payante, le serveur répond 402 avec un prix, et l'agent réessaie avec un paiement signé, généralement en stablecoins réglés on-chain. C'est un compteur de paiement par appel pour les API, les données et le contenu — l'outil qu'il faut quand l'achat est une seule requête, et la mauvaise forme pour un panier.

Les quatre sont complémentaires, pas rivaux, et la plupart des systèmes réels les combinent : l'UCP exécute le parcours d'achat, AP2 peut fournir la preuve signée à l'intérieur, x402 tarifie les appels individuels en chemin, et ACP est le chemin de paiement sur les surfaces d'OpenAI. C'est aussi la limite du vérificateur de ce site : le vérificateur UCP ne lit que les profils UCP. Il ne télécharge ni ne valide les documents ACP, AP2 ou x402, donc une boutique peut être prête pour l'UCP tout en n'ayant aucune présence ACP ou AP2 — les protocoles sont indépendants, et l'absence de l'un n'est pas un échec de l'autre.

Ce que fait le vérificateur UCP — et ce qu'il ne fait pas

Le vérificateur télécharge https://<cible>/.well-known/ucp via le service de vérification côté serveur — votre navigateur ne télécharge jamais la cible directement, car les règles d'origine croisée bloqueraient la plupart des boutiques — puis il parcourt le profil comme le fait la spécification. Il vérifie que le document est accessible en HTTPS sans redirection (une redirection est un échec, selon la spec), lit l'en-tête Cache-Control et cite sa valeur réelle, analyse le JSON et signale l'erreur d'analyse exacte en cas d'échec, et vérifie que les trois champs obligatoires sont présents, que la version est une date, et que la version n'est pas antérieure à 2026-08-25. Il énumère chaque service avec son transport et sa version, chaque gestionnaire de paiement, et chaque capacité avec le service auquel elle appartient, et il sonde chaque endpoint déclaré pour voir s'il est accessible. Le verdict est l'un des trois : prêt pour l'UCP, partiel, ou pas UCP — un 404 sur le profil est le cas négatif habituel, et le vérificateur le dit explicitement.

Ce qu'il ne fait pas compte tout autant. Il ne passe pas de commande, ne s'authentifie pas comme acheteur, et ne valide pas la cryptographie des gestionnaires de paiement — la présence d'un tableau keys[] prouve la provenance (les clés appartiennent au domaine qui les a publiées), pas la confiance, et la spécification le dit en ces termes mêmes. Il ne vérifie pas les documents ACP, AP2 ou x402. Et un résultat propre n'est pas une promesse que le paiement aboutira : le profil est de la publicité, pas une transaction, et l'endpoint derrière lui peut encore exiger une authentification, un compte acheteur ou l'approbation du commerçant avant de faire quoi que ce soit. Une vérification propre signifie que la boutique se décrit correctement et peut être découverte ; que l'achat aboutisse est l'affaire des propres systèmes de la boutique. Pour le tableau plus large — si un site est prêt pour les agents en général, fichier de découverte inclus — le vérificateur de préparation aux agents contrôle le fichier UCP parmi ses autres signaux.

Essayez vous-même : un profil UCP minimal, annoté par sa propre forme

{
  "ucp": {
    "version": "2026-08-25",
    "services": {
      "dev.ucp.shopping": [
        {
          "version": "2026-08-25",
          "transport": "rest",
          "endpoint": "https://business.example.com/ucp/v1",
          "spec": "https://ucp.dev/2026-08-25/specification/overview/",
          "schema": "https://ucp.dev/2026-08-25/services/shopping/rest.openapi.json"
        },
        {
          "version": "2026-08-25",
          "transport": "mcp",
          "endpoint": "https://business.example.com/ucp/mcp",
          "spec": "https://ucp.dev/2026-08-25/specification/overview/",
          "schema": "https://ucp.dev/2026-08-25/services/shopping/mcp.openrpc.json"
        }
      ]
    },
    "capabilities": {
      "dev.ucp.shopping.checkout": [
        {
          "version": "2026-08-25",
          "spec": "https://ucp.dev/2026-08-25/specification/shopping/checkout",
          "schema": "https://ucp.dev/2026-08-25/schemas/shopping/checkout.json"
        }
      ]
    },
    "payment_handlers": {
      "com.example.processor_tokenizer": [
        {
          "id": "processor_tokenizer",
          "version": "2026-08-25",
          "spec": "https://example.com/specs/payments/processor_tokenizer",
          "schema": "https://example.com/specs/payments/merchant_tokenizer.json"
        }
      ]
    }
  }
}

Sources

Questions fréquentes

Ma boutique n'a pas de /.well-known/ucp. Cela signifie-t-il que les assistants IA ne peuvent pas vendre mes produits ?

Non. Un 404 sur le profil signifie seulement que la boutique n'est pas UCP : les assistants peuvent toujours l'atteindre par l'ancienne voie, via des liens, des flux et des résultats de recherche. L'UCP est une porte d'entrée facultative et lisible par machine, pas une condition pour vendre en ligne. Les boutiques Shopify publient le profil automatiquement ; sur d'autres plateformes, vous le publiez vous-même, ou votre plateforme ou votre prestataire de paiement le publie pour vous. Le verdict « pas UCP » du vérificateur est un constat, pas une mauvaise note — il vous dit que la porte n'est pas là, pas que la boutique est fermée.

Le vérificateur m'avertit que ma version UCP est ancienne. Dois-je mettre à jour ?

Pas immédiatement, et pas de panique. Les anciennes versions continuent de fonctionner pour les clients qui les parlent — c'est à cela que sert supported_versions — mais un assistant qui ne parle que la version actuelle ne trouvera pas de version mutuellement supportée, et les outils construits pour la nouvelle version risquent de chercher des noms et des champs que votre profil n'utilise plus (signing_keys[] est le cas célèbre). Quand vous mettez à jour, mettez à jour ensemble les schémas, les noms de capacités et la lecture des champs de clés, puis vérifiez à nouveau quelles capacités sont réellement négociées ensuite ; un changement de version seulement sur le papier, avec des identifiants périmés en dessous, est pire que de rester délibérément sur l'ancienne version.

Une boutique réussit la vérification — cela garantit-il que le paiement fonctionnera ?

Non. Le profil est de la publicité, pas une transaction : il dit ce que la boutique offre et où le trouver, et le vérificateur contrôle que la publicité est bien formée. Il ne passe jamais de commande, ne se connecte jamais comme acheteur, et ne valide jamais la cryptographie des gestionnaires de paiement. L'endpoint de paiement derrière le profil peut encore exiger une authentification, un compte acheteur ou l'approbation du commerçant, et le gestionnaire de paiement peut refuser le paiement. Considérez une vérification propre comme « découvrable et décrite correctement » — que l'achat aboutisse reste le travail de la boutique.