OpenClaw ecommerce agent : cas d'usage complet
Montez un agent e-commerce OpenClaw pour gérer catalogue, commandes et relances clients, avec architecture claire et code Shopify.
OpenClaw ecommerce agent
Introduction
L'e-commerce cumule des tâches répétitives, sensibles au timing et faciles à standardiser. C'est donc un terrain idéal pour un agent métier bien borné. Un openclaw ecommerce agent peut surveiller un catalogue, qualifier des commandes à risque et déclencher des relances client sans transformer votre boutique en boîte noire fragile. Si vous avez déjà vu OpenClaw pour le business, l'étape suivante consiste à passer d'un concept rentable à un workflow concret. Dans ce guide, vous allez voir une architecture réaliste, trois skills Shopify et une orchestration capable de faire gagner plusieurs heures par semaine.
Résumé rapide
- Besoin couvert : catalogue, commandes, relances clients dans un seul workflow OpenClaw
- Stack choisie : OpenClaw + Shopify Admin API + SMTP ou API email
- Gain réaliste : 3 heures de gestion manuelle par jour réduites à 10 à 20 minutes de supervision
- Quand l'utiliser : boutique avec 100+ références, volume de commandes quotidien, règles métier stables
- Quand l'éviter : SAV complexe, remboursements litigieux, décisions commerciales à forte valeur
Explication
Un agent e-commerce OpenClaw n'est pas un chatbot branché sur une boutique. C'est un orchestrateur qui enchaîne des skills bornés, chacun responsable d'une action précise. Si vous voulez revoir les bases, commencez par comprendre les agents OpenClaw. Ici, l'objectif est simple : connecter la boutique à des opérations à faible ambiguïté, puis faire circuler un contexte commun entre les étapes.
Dans un contexte e-commerce, cette approche est utile pour trois raisons. D'abord, les données sont déjà structurées, produits, stocks, commandes, clients, tags. Ensuite, les actions attendues sont répétitives, par exemple publier une mise à jour de stock, détecter une commande bloquée ou relancer un panier abandonné. Enfin, le ROI est vite mesurable, car chaque automation remplace une séquence opératoire humaine connue.
L'architecture la plus robuste consiste à séparer les responsabilités : un skill lit et corrige le catalogue, un autre surveille les commandes, un troisième prépare les relances. L'agent central décide de l'ordre d'exécution et stoppe les actions quand un garde-fou n'est pas respecté. Vous obtenez ainsi une automation e-commerce IA pilotable, testable et auditable.
Développement principal
Prenons une boutique Shopify de 1 200 références, 80 commandes par jour et une équipe ops de deux personnes. Le but de l'agent est de tourner toutes les 30 minutes, de détecter les écarts et de ne pousser que les actions sûres.
Architecture cible
+----------------------+
| OpenClaw Orchestrator |
+-----------+----------+
|
+--------------------+--------------------+
| | |
v v v
+---------------+ +----------------+ +----------------+
| CatalogueSkill| | OrdersSkill | | FollowUpSkill |
+-------+-------+ +--------+-------+ +--------+-------+
| | |
v v v
Shopify Products Shopify Orders Shopify Customers
+ Inventory API + Fulfillment + Email provider
Le contexte partagé peut ressembler à ceci :
context = {
"shop": "acme-store",
"dry_run": True,
"inventory_feed_url": "https://erp.local/feed.json",
"pending_order_ids": [],
"followup_candidates": [],
"alerts": []
}
Skill 1 : mise à jour du catalogue
Le premier skill compare une source de vérité externe, souvent ERP ou PIM, avec Shopify. Il corrige les stocks, les prix ou les tags produits. Sur une boutique moyenne, c'est facilement 60 à 90 minutes de travail manuel par jour.
import requests
from openclaw.skills import BaseSkill, SkillResult
class CatalogueSyncSkill(BaseSkill):
name = "catalogue_sync"
description = "Synchronise stock et prix Shopify depuis un flux ERP."
def execute(self, inventory_feed_url: str, shop: str, token: str) -> SkillResult:
feed = requests.get(inventory_feed_url, timeout=20).json()
headers = {"X-Shopify-Access-Token": token}
updated = []
for item in feed["items"]:
payload = {
"product": {
"id": item["shopify_product_id"],
"variants": [{
"id": item["shopify_variant_id"],
"price": item["price"],
"inventory_quantity": item["stock"]
}]
}
}
url = f"https://{shop}.myshopify.com/admin/api/2025-01/products/{item['shopify_product_id']}.json"
requests.put(url, json=payload, headers=headers, timeout=20)
updated.append(item["sku"])
return SkillResult(success=True, data={"catalogue_updated": updated})
En production, on ajoute une logique d'écart maximal, par exemple bloquer toute variation de prix supérieure à 20%. Pour enrichir votre boîte à outils, le guide exemples de skills OpenClaw donne d'autres patterns réutilisables.
Skill 2 : surveillance et gestion des commandes
Le deuxième skill parcourt les commandes ouvertes, détecte les statuts anormaux et crée une liste d'actions. Ici, on ne cherche pas à tout automatiser, mais à réduire le tri manuel.
import requests
from openclaw.skills import BaseSkill, SkillResult
class OrdersWatchSkill(BaseSkill):
name = "orders_watch"
description = "Repère les commandes à risque ou en retard."
def execute(self, shop: str, token: str) -> SkillResult:
headers = {"X-Shopify-Access-Token": token}
url = f"https://{shop}.myshopify.com/admin/api/2025-01/orders.json?status=open&fulfillment_status=unfulfilled"
orders = requests.get(url, headers=headers, timeout=20).json()["orders"]
flagged = []
for order in orders:
if order["financial_status"] != "paid":
continue
if order["total_price"] > "250" or "express" in order.get("tags", "").lower():
flagged.append({
"id": order["id"],
"reason": "priority_review",
"customer": order["customer"]["email"]
})
return SkillResult(success=True, data={"pending_order_ids": flagged})
La sortie de ce skill peut alimenter Slack, une file interne ou un dashboard. Dans la pratique, il transforme 45 minutes de vérification dispersée en une liste priorisée revue en moins de 10 minutes. Pour la logique d'automatisation plus large autour de la boutique, vous pouvez compléter avec le guide automatisation e-commerce avec agents IA.
Skill 3 : relances clients automatisées
Le troisième skill prépare des messages transactionnels ou commerciaux, par exemple pour panier abandonné, commande retardée ou demande d'avis post-achat. La règle clé est de rester sur des scénarios fermés et vérifiables.
from openclaw.skills import BaseSkill, SkillResult
from datetime import datetime, timedelta
class FollowUpSkill(BaseSkill):
name = "follow_up"
description = "Construit des relances client à partir des événements Shopify."
def execute(self, orders: list, now: str) -> SkillResult:
now_dt = datetime.fromisoformat(now)
messages = []
for order in orders:
created_at = datetime.fromisoformat(order["created_at"])
if now_dt - created_at > timedelta(hours=24) and order["fulfillment_status"] is None:
messages.append({
"to": order["customer"]["email"],
"template": "delay_update",
"variables": {
"first_name": order["customer"]["first_name"],
"order_name": order["name"]
}
})
return SkillResult(success=True, data={"followup_candidates": messages})
Au lieu d'envoyer directement tous les emails, beaucoup d'équipes préfèrent un mode hybride : génération automatique, validation humaine pour les premiers jours, puis bascule graduelle vers l'envoi autonome sur les cas simples. C'est souvent la meilleure voie pour une openclaw boutique en ligne qui veut progresser sans risque brutal.
Orchestration multi-skills
L'orchestrateur exécute ces blocs dans l'ordre, partage le contexte et stoppe si un signal critique apparaît.
from openclaw import Agent
agent = Agent(name="ecommerce-ops")
agent.register(CatalogueSyncSkill())
agent.register(OrdersWatchSkill())
agent.register(FollowUpSkill())
result = agent.run(context={
"shop": "acme-store",
"dry_run": True,
"inventory_feed_url": "https://erp.local/feed.json"
})
Le point important n'est pas seulement la séquence, mais les règles de gouvernance : dry_run par défaut, arrêt si trop d'objets sont touchés, journalisation de chaque action, et escalade humaine si un seuil de confiance n'est pas atteint. Avec ces garde-fous, l'agent openclaw commandes devient un accélérateur opérationnel plutôt qu'une source d'incidents.
Exemple concret
Imaginez une marque DTC qui vend des accessoires maison. Chaque matin, l'équipe ops met à jour 150 niveaux de stock, contrôle 20 commandes bloquées et relance manuellement les clients dont l'expédition tarde. Le total représente environ 3 heures de travail.
Le workflow OpenClaw peut être reproduit ainsi :
- Le
CatalogueSyncSkillrécupère un flux ERP à 8h00 et met à jour les variantes Shopify en modedry_runpendant une semaine. - Le
OrdersWatchSkilltourne toutes les 30 minutes et remonte uniquement les commandes payées mais non expédiées au-delà de 24 heures ou supérieures à 250 euros. - Le
FollowUpSkillgénère un brouillon d'email transactionnel avec prénom, numéro de commande et statut attendu. - Un skill d'envoi séparé ne part que si le message respecte un template validé.
Résultat typique : 150 mises à jour catalogue traitées en moins de 5 minutes, 20 commandes revues dans une file priorisée, 12 relances préparées automatiquement. L'équipe ne passe plus son temps à chercher les cas, elle ne traite que les exceptions. Si vous devez ensuite industrialiser l'hébergement, renvoyez cette partie vers installer OpenClaw sur un VPS plutôt que de la mélanger au workflow métier.
Bonnes pratiques
La première erreur consiste à vouloir automatiser des cas ambigus trop tôt. Commencez par les processus à règles stables : stock, tags, relances transactionnelles, contrôle d'écarts. Laissez de côté les remboursements sensibles ou les réponses SAV émotionnelles.
Deuxième point, imposez des garde-fous chiffrés. Exemples utiles : pas plus de 50 produits modifiés par exécution, aucune baisse de prix supérieure à 20%, aucun email sans template approuvé. Sans ces seuils, une erreur de flux amont peut se propager très vite.
Troisième point, journalisez tout. Chaque skill doit produire un log structuré avec identifiant Shopify, action, ancien état, nouvel état et motif. C'est indispensable pour tester, corriger et auditer.
Enfin, intégrez le CTA au bon moment : si votre objectif est d'aller plus loin que ce cas unitaire, prêt à passer à l'automatisation complète de votre e-commerce ? Découvrez comment OpenClaw automatise vos processus e-commerce de bout en bout.
Questions fréquentes
OpenClaw peut-il gérer une boutique Shopify seul ?
Oui pour des tâches bornées comme la synchronisation catalogue, la détection de commandes à risque ou les relances transactionnelles. Non pour des décisions commerciales complexes sans supervision. Un openclaw ecommerce agent doit opérer avec des règles métier, des seuils de sécurité et un mode dry run avant toute autonomie réelle.
Faut-il choisir Shopify ou WooCommerce pour ce type d'agent ?
Les deux fonctionnent, mais Shopify est souvent plus rapide à intégrer pour un agent catalogue OpenClaw grâce à une API homogène et une structure de données stable. WooCommerce convient aussi si votre boutique repose déjà fortement sur WordPress et des plugins métier spécifiques.
Quel est le gain réel d'une automation e-commerce IA ?
Sur une boutique de taille moyenne, l'automation e-commerce IA supprime surtout le tri manuel. Les gains les plus réalistes sont 1 à 3 heures économisées par jour, une meilleure réactivité sur les commandes bloquées et moins d'oublis sur les relances clients. Le ROI vient de la régularité, pas d'un effet magique.
Est-ce risqué d'envoyer des emails clients via OpenClaw ?
Oui si vous laissez l'agent écrire librement. Le bon pattern consiste à utiliser des templates verrouillés, des variables vérifiables et un périmètre clair, par exemple retard d'expédition ou demande d'avis post-achat. Pour les messages sensibles, gardez une validation humaine.
Articles liés
Un agent e-commerce OpenClaw est pertinent quand vos opérations sont répétitives, mesurables et déjà partiellement normalisées. Le vrai levier n'est pas de tout déléguer, mais d'automatiser les cas simples pour concentrer l'équipe sur les exceptions. La prochaine étape logique est donc d'étendre ce premier workflow à d'autres briques du business.
Restez informé sur les agents IA
Nouveaux tutoriels, comparatifs et guides pratiques directement dans votre boîte mail.