Intégration API Shopify e-commerce – Guide 2025

1. 1. Pourquoi intégrer Shopify via API ? Les enjeux e-commerce
2. 2. Présentation technique des APIs Shopify (REST Admin API, GraphQL Admin API, Storefront API)
3. 3. Authentification et sécurité : Access Token, OAuth 2.0, scopes d’accès
4. 4. Modèle de données Shopify : produits, clients, commandes, inventaire
5. 5. CRUD complet avec l’API Shopify (GET / POST / PUT / DELETE)
6. 6. Connecter Shopify à votre ERP, CRM ou outil marketing
7. 7. Automatiser les workflows e-commerce avec l’API Shopify
8. 8. Webhooks Shopify : événements temps réel (commandes, remboursements, stocks)
9. 9. Bonnes pratiques techniques : limites de taux, performances, logs, versioning d’API
10. 10. Exemple complet d’intégration Shopify ↔ ERP (code inclus)
11. 11. Sécurité, conformité et RGPD dans vos intégrations Shopify
12. 12. Monitoring et supervision des intégrations Shopify
13. 13. Autres solutions du marché
14. Passez à l’action avec Dawap

1. Pourquoi intégrer Shopify via API ? Les enjeux e-commerce

Shopify est bien plus qu’une simple solution de boutique en ligne : c’est une plateforme e-commerce complète, capable de gérer produits, commandes, paiements, clients et logistique. Mais pour libérer tout son potentiel, il faut aller au-delà du back-office et tirer parti de l’API Shopify. L’intégration via API permet de connecter Shopify à vos autres outils métier (ERP, CRM, marketing automation, BI, entrepôt…) et d’automatiser vos processus e-commerce à grande échelle.

Un Shopify connecté, c’est un e-commerce plus intelligent

Sans intégration API, vos données e-commerce vivent en silos : les stocks de l’ERP, les ventes Shopify, les contacts CRM ou les campagnes marketing ne sont jamais totalement synchronisés. L’API Shopify supprime ces frictions en centralisant vos informations dans un écosystème cohérent et automatisé.

Les bénéfices clés d’une intégration API Shopify

Exemple concret : création automatique d’un client Shopify depuis votre CRM

Grâce à l’API Admin, vous pouvez créer un client Shopify directement depuis un autre système, comme votre CRM ou ERP. Voici un exemple simple d’appel API pour créer un client :

POST https://{shop}.myshopify.com/admin/api/2025-01/customers.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "customer": {
    "first_name": "Sophie",
    "last_name": "Martin",
    "email": "sophie.martin@example.com",
    "phone": "+33611223344",
    "addresses": [
      {
        "address1": "12 rue des Lilas",
        "city": "Lyon",
        "country": "France"
      }
    ]
  }
}
        

En un seul appel, le client est ajouté à Shopify, visible dans votre back-office et immédiatement exploitable pour vos campagnes marketing, notifications d’expédition ou relances post-achat.

2. Présentation technique des APIs Shopify (REST Admin API, GraphQL Admin API, Storefront API)

Shopify propose un écosystème d’APIs particulièrement riche et moderne, pensé pour s’intégrer facilement à n’importe quel système tiers (ERP, CRM, OMS, outil marketing, application mobile, etc.). Trois APIs principales couvrent la majorité des besoins e-commerce :

1️⃣ REST Admin API – la base pour gérer votre boutique

L’Admin REST API permet de gérer les principales ressources Shopify : produits, commandes, clients, inventaire, etc. Chaque ressource possède un endpoint REST standard, avec les méthodes GET, POST, PUT et DELETE.

GET https://{shop}.myshopify.com/admin/api/2025-01/products.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

Cette requête retourne la liste complète des produits disponibles dans votre boutique. Vous pouvez également filtrer ou paginer les résultats avec les paramètres limit et since_id.

2️⃣ GraphQL Admin API – flexible et optimisée

L’API GraphQL est aujourd’hui la méthode recommandée par Shopify. Elle vous permet d’interroger plusieurs ressources à la fois tout en contrôlant le volume de données retournées.

Exemple de requête GraphQL pour récupérer les 3 dernières commandes avec le nom du client et le total payé :

POST https://{shop}.myshopify.com/admin/api/2025-01/graphql.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "query": "{
    orders(first: 3, sortKey: CREATED_AT, reverse: true) {
      edges {
        node {
          id
          name
          totalPriceSet {
            shopMoney { amount currencyCode }
          }
          customer { firstName lastName email }
        }
      }
    }
  }"
}
        

Cette requête ne récupère que les champs nécessaires, réduisant la charge côté serveur. GraphQL est idéal pour les intégrations complexes (reporting, data warehouse, automatisations personnalisées).

3️⃣ Storefront API – pour le e-commerce headless

L’API Storefront est une API publique (souvent côté front) utilisée pour construire des sites headless Shopify avec Next.js, Vue, React ou tout autre framework moderne. Elle permet de récupérer les produits, le panier, les collections et de gérer le checkout complet.

Exemple de requête GraphQL pour afficher les 5 produits les plus récents sur un front personnalisé :

POST https://{shop}.myshopify.com/api/2025-01/graphql.json
X-Shopify-Storefront-Access-Token: YOUR_STOREFRONT_TOKEN
Content-Type: application/json

{
  "query": "{
    products(first: 5) {
      edges {
        node {
          title
          handle
          description
          images(first: 1) {
            edges { node { src altText } }
          }
          variants(first: 1) {
            edges { node { price { amount currencyCode } } }
          }
        }
      }
    }
  }"
}
        

L’API Storefront est donc le cœur des architectures headless e-commerce, permettant de combiner Shopify avec un front React/Next.js, un CMS externe ou une app mobile native.

3. Authentification et sécurité : Access Token, OAuth 2.0, scopes d’accès

Shopify sécurise l’accès à ses APIs via un système d’authentification par token. Que vous développiez une app privée, une application publique ou un middleware Dawap connecté à Shopify, vous devrez utiliser un Access Token généré à partir d’un compte, d’une app ou d’un flux OAuth 2.0.

1️⃣ Les trois modes d’accès API possibles

2️⃣ App privée – la méthode la plus simple pour vos intégrations internes

Si vous développez un connecteur ou un script interne, la méthode la plus rapide consiste à créer une App privée Shopify. Une fois générée, vous obtenez un Access Token à utiliser dans vos requêtes.

GET https://{shop}.myshopify.com/admin/api/2025-01/orders.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

Le token est permanent tant que l’app reste active. Shopify recommande d’utiliser ce type d’app uniquement pour les intégrations serveur-à-serveur sécurisées.

3️⃣ App publique – OAuth 2.0 pour les intégrations SaaS

Si vous développez une application que plusieurs boutiques Shopify doivent pouvoir connecter (par exemple un outil CRM ou de facturation), vous devez implémenter le flux d’authentification OAuth 2.0. Le marchand autorise explicitement votre app à accéder à sa boutique.

Étape 1 – Rediriger vers l’autorisation Shopify :

GET https://{shop}.myshopify.com/admin/oauth/authorize
?client_id=YOUR_CLIENT_ID
&scope=read_orders,write_products
&redirect_uri=https://yourapp.com/callback
&state=random-string
        

Étape 2 – Récupérer le code d’autorisation et échanger contre un token :

POST https://{shop}.myshopify.com/admin/oauth/access_token
Content-Type: application/json

{
  "client_id": "YOUR_CLIENT_ID",
  "client_secret": "YOUR_CLIENT_SECRET",
  "code": "AUTHORIZATION_CODE_FROM_CALLBACK"
}
        

Réponse :

{
  "access_token": "shpua_8b1c3exampletoken9c2d",
  "scope": "read_orders,write_products"
}
        

L’app peut ensuite utiliser cet access_token pour interagir avec l’API du marchand. Ce flux est conforme aux standards OAuth 2.0 et recommandé pour les applications publiques multi-boutiques.

4️⃣ Les scopes Shopify – définir les permissions d’accès

Les scopes permettent de contrôler finement ce que votre app peut lire ou modifier dans la boutique. Chaque token (privé ou OAuth) doit inclure les scopes nécessaires, et seulement ceux-là.

5️⃣ Sécuriser les communications et l’usage des tokens

Shopify impose des standards de sécurité élevés, mais il revient à chaque intégrateur de renforcer la protection des échanges :

• Tous les appels doivent être faits en HTTPS (TLS 1.2 minimum).
• Les tokens ne doivent jamais être stockés dans le front-end ou exposés dans le code client.
• Journaliser et auditer les appels sensibles (commandes, paiements, suppression).
• Limiter les accès par IP si le middleware Dawap est sur serveur fixe.
• Mettre en place un système d’alerte sur erreurs 401/403 (token expiré ou révoqué).

4. Modèle de données Shopify : produits, clients, commandes, inventaire

L’API Shopify repose sur un modèle de données structuré et hiérarchique permettant de gérer tout le cycle de vie e-commerce : du catalogue produit à la commande client, en passant par la gestion des stocks et des paiements. Comprendre ces entités et leurs relations est essentiel pour bâtir une intégration fiable et cohérente.

1️⃣ Produit (Product) et variantes (Variant)

Un produit dans Shopify peut contenir plusieurs variantes (ex. taille, couleur, modèle). Chaque variante possède son propre prix, SKU et stock. L’API permet d’accéder à ces informations et de les mettre à jour individuellement.

GET https://{shop}.myshopify.com/admin/api/2025-01/products/123456789.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

{
  "product": {
    "id": 123456789,
    "title": "T-shirt coton bio",
    "vendor": "Dawap Apparel",
    "product_type": "Vêtements",
    "status": "active",
    "variants": [
      {
        "id": 987654321,
        "title": "Taille M / Bleu",
        "price": "29.90",
        "sku": "TSHIRT-BLEU-M",
        "inventory_quantity": 45
      },
      {
        "id": 987654322,
        "title": "Taille L / Bleu",
        "price": "29.90",
        "sku": "TSHIRT-BLEU-L",
        "inventory_quantity": 20
      }
    ]
  }
}
        

👉 Les variantes sont des objets indépendants dans Shopify, mais rattachées à un produit parent. Elles permettent de gérer précisément les stocks et la tarification par déclinaison.

2️⃣ Client (Customer)

L’objet Customer regroupe toutes les informations personnelles et transactionnelles du client. Il est synchronisable avec votre CRM pour le scoring, la segmentation ou la fidélisation.

GET https://{shop}.myshopify.com/admin/api/2025-01/customers/456789.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

{
  "customer": {
    "id": 456789,
    "email": "amelie.dupont@example.com",
    "first_name": "Amélie",
    "last_name": "Dupont",
    "phone": "+33612345678",
    "orders_count": 3,
    "total_spent": "152.70",
    "default_address": {
      "address1": "22 rue Victor Hugo",
      "city": "Bordeaux",
      "country": "France"
    },
    "tags": "VIP, newsletter"
  }
}
        

Chaque client peut être enrichi de tags et notes internes pour la segmentation marketing. Shopify stocke également l’historique des commandes liées à chaque client, facilitant la synchronisation CRM.

3️⃣ Commande (Order)

L’objet Order est au cœur du modèle Shopify. Il regroupe le panier, le client, les produits, les paiements et les statuts logistiques. Chaque commande est horodatée et peut être mise à jour (ex. statut de livraison).

GET https://{shop}.myshopify.com/admin/api/2025-01/orders/789123.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

{
  "order": {
    "id": 789123,
    "name": "#1054",
    "created_at": "2025-10-23T14:22:00Z",
    "financial_status": "paid",
    "fulfillment_status": "fulfilled",
    "total_price": "89.90",
    "currency": "EUR",
    "customer": { "id": 456789, "email": "amelie.dupont@example.com" },
    "line_items": [
      { "title": "T-shirt coton bio - M / Bleu", "quantity": 1, "price": "29.90" },
      { "title": "Sweat organic - L / Noir", "quantity": 1, "price": "60.00" }
    ],
    "shipping_address": {
      "first_name": "Amélie",
      "address1": "22 rue Victor Hugo",
      "city": "Bordeaux",
      "country": "France"
    }
  }
}
        

Chaque commande est liée à un client et à plusieurs produits. Shopify génère aussi des webhooks d’événements (order/create, order/fulfilled, etc.) que vous pouvez exploiter pour mettre à jour votre ERP ou vos notifications clients.

4️⃣ Inventaire (InventoryLevel & Location)

Shopify gère les stocks par emplacement (location) : boutique, entrepôt, dropshipper… Les niveaux de stock sont représentés par l’objet InventoryLevel, qui peut être mis à jour via API ou synchronisé automatiquement depuis un ERP.

GET https://{shop}.myshopify.com/admin/api/2025-01/inventory_levels.json?inventory_item_ids=987654321
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

{
  "inventory_levels": [
    {
      "inventory_item_id": 987654321,
      "location_id": 12345,
      "available": 45,
      "updated_at": "2025-10-23T10:45:00Z"
    }
  ]
}
        

Ces données permettent une synchronisation bidirectionnelle entre Shopify et votre ERP : dès qu’un stock évolue dans un système, il est mis à jour automatiquement dans l’autre.

5. CRUD complet avec l’API Shopify (GET / POST / PUT / DELETE)

L’API Shopify permet d’effectuer toutes les opérations CRUD (Create, Read, Update, Delete) sur les ressources principales de votre boutique : produits, clients, commandes, stocks, etc. Ces opérations reposent sur des endpoints REST simples et standardisés, toujours protégés par un Access Token sécurisé.

1️⃣ Lire des données (GET)

Pour récupérer des données, il suffit d’envoyer une requête GET sur l’un des endpoints Shopify. Exemple : lire la liste des 5 derniers produits créés.

GET https://{shop}.myshopify.com/admin/api/2025-01/products.json?limit=5
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

{
  "products": [
    { "id": 1111, "title": "Sweat organic", "status": "active" },
    { "id": 1112, "title": "T-shirt coton bio", "status": "active" }
  ]
}
        

Vous pouvez filtrer vos résultats à l’aide de paramètres comme status=active, created_at_min ou encore updated_at_max.

2️⃣ Créer une donnée (POST)

Pour créer une nouvelle ressource (produit, client, commande…), vous utilisez la méthode POST. Exemple : ajout d’un nouveau produit dans le catalogue Shopify.

POST https://{shop}.myshopify.com/admin/api/2025-01/products.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "product": {
    "title": "Sweat capuche éco-responsable",
    "body_html": "Sweat en coton bio avec capuche ajustable",
    "vendor": "Dawap Apparel",
    "product_type": "Vêtements",
    "variants": [
      {
        "option1": "Taille M",
        "price": "49.90",
        "sku": "SWEAT-HOODIE-M"
      }
    ]
  }
}
        

Shopify renverra un objet JSON complet du produit nouvellement créé, avec son ID unique.

{
  "product": {
    "id": 125678901,
    "title": "Sweat capuche éco-responsable",
    "status": "active"
  }
}
        

3️⃣ Mettre à jour une donnée (PUT)

La méthode PUT permet de modifier une ressource existante. Exemple : mise à jour du prix d’un produit déjà présent dans Shopify.

PUT https://{shop}.myshopify.com/admin/api/2025-01/products/125678901.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "product": {
    "id": 125678901,
    "variants": [
      { "id": 987654321, "price": "44.90" }
    ]
  }
}
        

Vous pouvez modifier une propriété spécifique sans recréer tout l’objet. L’API retourne toujours la ressource mise à jour avec un horodatage de modification.

{
  "product": {
    "id": 125678901,
    "updated_at": "2025-10-24T12:14:32Z",
    "variants": [
      { "id": 987654321, "price": "44.90" }
    ]
  }
}
        

4️⃣ Supprimer une donnée (DELETE)

Pour supprimer une ressource, utilisez la méthode DELETE. Exemple : suppression d’un produit ou d’un client spécifique.

DELETE https://{shop}.myshopify.com/admin/api/2025-01/products/125678901.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

Si la requête est correcte, Shopify renverra un statut 200 OK ou 204 No Content, confirmant que la ressource a été supprimée avec succès.

6. Connecter Shopify à votre ERP, CRM ou outil marketing

Shopify ne vit pas seul dans votre écosystème digital. Pour tirer toute sa puissance, il doit être connecté à vos autres briques métier : ERP (gestion des stocks et facturation), CRM (relation client) et outil marketing (automation, campagnes, emailing). L’API Shopify permet de centraliser, synchroniser et automatiser ces échanges en temps réel.

1️⃣ Connecter Shopify à un ERP

L’intégration ERP ↔ Shopify permet de synchroniser automatiquement les produits, les stocks et les commandes. C’est un levier majeur pour fiabiliser la gestion et éviter les ruptures ou erreurs de facturation.

Exemple d’un flux typique : lorsqu’une commande est passée sur Shopify, elle est envoyée automatiquement dans l’ERP pour traitement logistique et facturation.

// Exemple Node.js – Synchroniser une commande Shopify avec l’ERP Dawap
app.post("/webhooks/orders/create", async (req, res) => {
  const order = req.body;
  console.log("Nouvelle commande reçue :", order.name);

  await fetch("https://api.erp-dawap.fr/orders", {
    method: "POST",
    headers: { "Content-Type": "application/json", "Authorization": "Bearer ERP_TOKEN" },
    body: JSON.stringify({
      order_id: order.id,
      client: order.customer.email,
      total: order.total_price,
      date: order.created_at,
      items: order.line_items.map(i => ({
        sku: i.sku,
        quantity: i.quantity,
        price: i.price
      }))
    })
  });

  res.sendStatus(200);
});
        

👉 Ce type de webhook permet de relier Shopify à n’importe quel ERP compatible API, garantissant une mise à jour instantanée des commandes et stocks.

2️⃣ Connecter Shopify à un CRM

Le CRM devient la mémoire client de votre activité e-commerce. En le connectant à Shopify, vous unifiez vos contacts, vos historiques d’achat et vos données comportementales.

Exemple d’ajout automatique d’un client Shopify dans HubSpot via API REST :

POST https://api.hubapi.com/crm/v3/objects/contacts
Authorization: Bearer HUBSPOT_TOKEN
Content-Type: application/json

{
  "properties": {
    "email": "amelie.dupont@example.com",
    "firstname": "Amélie",
    "lastname": "Dupont",
    "shopify_last_order_total": "89.90",
    "shopify_tags": "VIP, Réachat"
  }
}
        

Ce flux permet d’enrichir votre CRM automatiquement avec la donnée Shopify, pour des campagnes marketing ciblées et une meilleure segmentation client.

3️⃣ Connecter Shopify à vos outils marketing

L’API Shopify facilite la connexion avec des outils marketing tiers afin d’automatiser les relances, newsletters et scénarios personnalisés.

4️⃣ Architecture type d’une intégration Dawap

Dawap conçoit des intégrations centralisées basées sur un middleware API : il reçoit les données de Shopify (via webhooks), les transforme et les renvoie aux systèmes cibles (ERP, CRM, marketing).

[Shopify API] ⇄ [Dawap Middleware] ⇄ [ERP / CRM / Marketing Tool]

🟢 Commande créée sur Shopify → webhook → Dawap Middleware → création commande ERP
🟢 Client mis à jour sur Shopify → push automatique → CRM
🟢 Stock modifié dans l’ERP → update → Shopify API
        

7. Automatiser les workflows e-commerce avec l’API Shopify

Automatiser vos workflows e-commerce avec l’API Shopify, c’est transformer des tâches manuelles en processus intelligents, connectés et sans friction. Grâce aux APIs REST / GraphQL et aux webhooks Shopify, vous pouvez déclencher des actions automatiques dès qu’un événement se produit sur votre boutique : nouvelle commande, mise à jour de stock, client créé, remboursement, etc.

1️⃣ Pourquoi automatiser vos workflows Shopify ?

Chaque jour, vos équipes passent des heures à traiter des tâches répétitives : export de commandes, mise à jour d’un CRM, envoi de notifications, suivi de stocks. L’automatisation via API réduit ces interventions humaines, tout en garantissant une donnée plus fiable et à jour.

2️⃣ Exemple de workflow : confirmation de commande + intégration ERP

Lorsqu’une commande est validée sur Shopify, un webhook orders/create peut automatiquement déclencher une série d’actions : génération de la facture dans l’ERP, notification client, mise à jour du stock et envoi du mail de confirmation.

// Exemple Node.js - Automatisation commande Shopify
app.post("/webhooks/orders/create", async (req, res) => {
  const order = req.body;

  // Étape 1 : Créer la commande dans l’ERP
  await fetch("https://api.erp-dawap.fr/orders", {
    method: "POST",
    headers: {
      "Authorization": "Bearer ERP_TOKEN",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      id_shopify: order.id,
      total: order.total_price,
      client: order.customer.email,
      produits: order.line_items.map(i => ({
        sku: i.sku,
        quantite: i.quantity
      }))
    })
  });

  // Étape 2 : Envoyer un email personnalisé via Brevo
  await fetch("https://api.brevo.com/v3/smtp/email", {
    method: "POST",
    headers: {
      "api-key": "BREVO_API_KEY",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      sender: { name: "Dawap Store", email: "shop@dawap.fr" },
      to: [{ email: order.customer.email }],
      subject: `Merci pour votre commande ${order.name}`,
      htmlContent: `
Bonjour ${order.customer.first_name},
Votre commande #${order.name} est confirmée 🎉
`
    })
  });

  res.sendStatus(200);
});
        

Ce flux automatique permet de gagner plusieurs minutes par commande et garantit que toutes les données sont à jour dans les outils métiers.

3️⃣ Automatiser la gestion des stocks et du service client

Shopify expose des endpoints API permettant de modifier dynamiquement les stocks et d’ajouter des métadonnées ou des tags à vos clients et commandes. Vous pouvez ainsi automatiser vos scénarios de support ou de logistique.

POST https://{shop}.myshopify.com/admin/api/2025-01/inventory_levels/set.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "location_id": 123456,
  "inventory_item_id": 987654,
  "available": 38
}
        

Ce type d’appel est utilisé pour mettre à jour les stocks automatiquement après une expédition, un retour produit ou une mise à jour depuis l’ERP.

4️⃣ Automatiser la fidélisation client

Grâce à l’API et aux webhooks customers/update ou orders/paid, vous pouvez mettre à jour les informations clients et automatiser les campagnes de fidélisation :

PUT https://{shop}.myshopify.com/admin/api/2025-01/customers/123456.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "customer": {
    "id": 123456,
    "tags": "VIP, Fidélité, A récompenser"
  }
}
        

Ce mécanisme peut être automatisé via Dawap Middleware : dès qu’un client dépasse un certain montant cumulé, son profil est enrichi automatiquement dans Shopify et synchronisé avec votre CRM ou outil marketing.

5️⃣ Outils et frameworks utiles pour automatiser Shopify

8. Webhooks Shopify : événements temps réel (commandes, remboursements, stocks)

Les webhooks Shopify permettent à votre application d’être notifiée en temps réel lorsqu’un événement important se produit dans votre boutique : commande créée, remboursement émis, client mis à jour ou stock modifié. C’est le cœur de toute intégration e-commerce en temps réel, garantissant la synchronisation parfaite entre Shopify et vos autres systèmes (ERP, CRM, BI, marketing...).

1️⃣ Qu’est-ce qu’un webhook Shopify ?

Un webhook est un appel HTTP automatique envoyé par Shopify vers votre serveur dès qu’un événement survient. Vous pouvez l’assimiler à une “notification push” API : au lieu d’interroger Shopify en boucle, c’est Shopify qui vous informe instantanément.

2️⃣ Comment configurer un webhook Shopify

Vous pouvez créer un webhook directement depuis l’interface Shopify Admin, ou via l’API REST. Exemple : création d’un webhook pour suivre la création de commandes.

POST https://{shop}.myshopify.com/admin/api/2025-01/webhooks.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "webhook": {
    "topic": "orders/create",
    "address": "https://api.dawap.fr/webhooks/orders/create",
    "format": "json"
  }
}
        

Shopify enverra désormais une requête POST vers l’URL fournie à chaque création de commande. Votre serveur doit répondre par un HTTP 200 OK pour valider la réception.

3️⃣ Exemple complet : réception d’un webhook “commande créée”

Voici un exemple d’implémentation Node.js d’un endpoint Dawap Middleware recevant un webhook de type orders/create, puis synchronisant la commande avec un ERP.

// Exemple Node.js – Webhook Shopify : commande créée
import express from "express";
import crypto from "crypto";

const app = express();
app.use(express.json({ type: "application/json" }));

const SHOPIFY_SECRET = "YOUR_WEBHOOK_SECRET";

// Vérification de la signature HMAC Shopify
function verifyShopifyWebhook(req) {
  const hmac = req.headers["x-shopify-hmac-sha256"];
  const body = JSON.stringify(req.body);
  const digest = crypto
    .createHmac("sha256", SHOPIFY_SECRET)
    .update(body, "utf8")
    .digest("base64");
  return digest === hmac;
}

app.post("/webhooks/orders/create", async (req, res) => {
  if (!verifyShopifyWebhook(req)) {
    return res.status(401).send("Invalid signature");
  }

  const order = req.body;
  console.log(`Commande reçue : ${order.name} - Total ${order.total_price} €`);

  // Synchronisation ERP Dawap
  await fetch("https://api.erp-dawap.fr/orders", {
    method: "POST",
    headers: {
      "Authorization": "Bearer ERP_TOKEN",
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      id_shopify: order.id,
      client: order.customer.email,
      total: order.total_price,
      statut: order.financial_status,
      produits: order.line_items.map(i => ({
        sku: i.sku,
        quantite: i.quantity
      }))
    })
  });

  res.sendStatus(200);
});

app.listen(4000, () => console.log("Webhook Dawap prêt sur le port 4000"));
        

Ce code reçoit la commande Shopify, vérifie son authenticité grâce à la signature HMAC, puis la réplique dans l’ERP Dawap. En moins d’une seconde, la commande est traitée et prête à être expédiée.

4️⃣ Sécurité et validation des webhooks

Shopify sécurise chaque webhook via une signature HMAC-SHA256 calculée à partir du contenu du message et de votre clé secrète. Vous devez vérifier cette signature avant de traiter les données, afin d’éviter toute requête falsifiée.

5️⃣ Autres webhooks utiles à connaître

9. Bonnes pratiques techniques : limites de taux, performances, logs, versioning d’API

Une intégration Shopify réussie ne repose pas seulement sur la logique métier, mais aussi sur une architecture performante, résiliente et maintenable. Shopify impose des règles strictes en matière de quotas d’appels API, de versioning et de sécurité. Voici les bonnes pratiques Dawap pour concevoir une intégration stable sur le long terme.

1️⃣ Limites de taux (API Rate Limits)

Shopify impose des limites d’appels pour garantir la performance globale de sa plateforme. Dépasser ces limites entraîne des erreurs 429 Too Many Requests. La clé : gérer la **throttling** intelligemment.

💡 Bonnes pratiques Dawap pour la gestion des quotas

• Implémenter une temporisation automatique (sleep ou retry) en cas d’erreur 429.
• Regrouper les appels dans des batchs ou utiliser les endpoints “bulk operations”.
• Privilégier GraphQL pour limiter le nombre de requêtes REST.
• Surveiller les en-têtes X-Shopify-Shop-Api-Call-Limit pour anticiper la saturation.

// Exemple Node.js - Gestion automatique du throttling Shopify
async function callShopifyAPI(url, options = {}) {
  const res = await fetch(url, options);

  if (res.status === 429) {
    const retryAfter = res.headers.get("Retry-After") || 2;
    console.warn(`⏳ Quota dépassé, nouvelle tentative dans ${retryAfter}s...`);
    await new Promise(r => setTimeout(r, retryAfter * 1000));
    return callShopifyAPI(url, options);
  }

  return res.json();
}
        

2️⃣ Optimiser les performances des intégrations

Pour les boutiques à fort volume (plusieurs milliers de produits ou commandes), il est essentiel de réduire le nombre d’appels et de paralléliser les traitements efficacement.

3️⃣ Journalisation et logs d’intégration

Les logs sont essentiels pour diagnostiquer les erreurs, mesurer la performance et assurer la traçabilité RGPD. Dawap recommande d’enregistrer chaque interaction avec l’API Shopify, sans conserver les données sensibles (tokens, PII).

// Exemple Node.js - Middleware de logs simplifié
app.use(async (req, res, next) => {
  const start = Date.now();
  res.on("finish", () => {
    const duration = Date.now() - start;
    console.log(`[${req.method}] ${req.url} - ${res.statusCode} (${duration}ms)`);
  });
  next();
});
        

4️⃣ Versioning des APIs Shopify

Shopify publie une nouvelle version d’API tous les trimestres (ex : 2025-01). Chaque version est supportée pendant 1 an. Il est donc crucial de maintenir votre intégration à jour pour éviter les ruptures de compatibilité.

GET https://{shop}.myshopify.com/admin/api/2025-01/orders.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

5️⃣ Sécurité et gouvernance technique

Enfin, une intégration performante doit aussi être sécurisée. Shopify et Dawap recommandent la mise en place de politiques de gouvernance technique :

• Rotation régulière des tokens (Access Tokens et secrets Webhooks).
• Contrôle d’accès basé sur le principe du moindre privilège.
• Chiffrement des logs et variables d’environnement sensibles.
• Audit régulier des appels API pour détecter les anomalies.

10. Exemple complet d’intégration Shopify ↔ ERP (code inclus)

Cette section illustre un flux d’intégration Shopify ↔ ERP tel qu’on le met en place chez Dawap. Objectif : automatiser la prise de commande, la préparation logistique, la mise à jour du statut et des stocks, sans action manuelle côté équipe e-commerce.

1️⃣ Étape 1 : Récupérer automatiquement la commande côté Shopify

Dès qu’une commande est créée/payette, Shopify envoie un webhook orders/create ou orders/paid vers le middleware Dawap. Exemple de payload simplifié envoyé par Shopify :

{
  "id": 789123,
  "name": "#1054",
  "created_at": "2025-10-23T14:22:00Z",
  "total_price": "89.90",
  "currency": "EUR",
  "financial_status": "paid",
  "customer": {
    "email": "amelie.dupont@example.com",
    "first_name": "Amélie",
    "last_name": "Dupont"
  },
  "line_items": [
    {
      "sku": "TSHIRT-BLEU-M",
      "title": "T-shirt coton bio - M / Bleu",
      "quantity": 1,
      "price": "29.90"
    },
    {
      "sku": "SWEAT-NOIR-L",
      "title": "Sweat organic - L / Noir",
      "quantity": 1,
      "price": "60.00"
    }
  ],
  "shipping_address": {
    "address1": "22 rue Victor Hugo",
    "city": "Bordeaux",
    "country": "France"
  }
}
        

👉 Pas besoin d’appeler l’API Shopify en boucle : Shopify “push” l’info en temps réel grâce au webhook.

2️⃣ Étape 2 : Envoyer cette commande vers l’ERP

Le middleware Dawap reçoit le webhook, transforme les données au format attendu par l’ERP, puis les pousse dans l’ERP. Exemple : création d’une commande dans l’ERP via API REST JSON.

POST https://api.mon-erp.com/orders
Authorization: Bearer ERP_TOKEN
Content-Type: application/json

{
  "external_source": "shopify",
  "external_order_id": 789123,
  "order_number": "#1054",
  "status": "paid",
  "total_ttc": 89.90,
  "currency": "EUR",
  "customer": {
    "email": "amelie.dupont@example.com",
    "firstname": "Amélie",
    "lastname": "Dupont",
    "shipping_city": "Bordeaux",
    "shipping_country": "France"
  },
  "items": [
    { "sku": "TSHIRT-BLEU-M", "qty": 1, "price_ttc": 29.90 },
    { "sku": "SWEAT-NOIR-L", "qty": 1, "price_ttc": 60.00 }
  ]
}
        

L’ERP crée alors :

3️⃣ Étape 3 : Mettre à jour Shopify avec le statut d’expédition

Quand l’ERP confirme : “colis expédié”, on met à jour la commande Shopify avec une fulfillment. Cela alimente le suivi client (email tracking, espace commande).

Exemple d’appel pour déclarer une commande comme expédiée avec un numéro de suivi :

POST https://{shop}.myshopify.com/admin/api/2025-01/orders/789123/fulfillments.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "fulfillment": {
    "tracking_company": "Colissimo",
    "tracking_number": "6A1234567890",
    "notify_customer": true,
    "line_items": [
      { "id": 1122334455, "quantity": 1 },
      { "id": 1122334456, "quantity": 1 }
    ]
  }
}
        

Résultat direct côté client :

4️⃣ Étape 4 : Mettre à jour le stock dans Shopify

Après l’expédition, l’ERP connaît le stock restant réel. Le middleware Dawap pousse ces nouvelles quantités dans Shopify pour éviter les ventes hors stock.

Exemple : mise à jour du stock d’un SKU précis pour un entrepôt donné.

POST https://{shop}.myshopify.com/admin/api/2025-01/inventory_levels/set.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
Content-Type: application/json

{
  "location_id": 123456,
  "inventory_item_id": 987654,
  "available": 42
}
        

Le stock est donc mis à jour automatiquement dans Shopify, sans intervention humaine, en cohérence avec l’ERP logistique.

5️⃣ Exemple de middleware Dawap (Node.js)

Ci-dessous, un exemple simplifié d’un middleware Dawap. Il reçoit un webhook de commande Shopify → envoie la commande à l’ERP → puis répond à Shopify.

// Middleware Dawap - intégration Shopify ↔ ERP
import express from "express";
import crypto from "crypto";

const app = express();
app.use(express.json({ type: "application/json" }));

const SHOPIFY_WEBHOOK_SECRET = "YOUR_WEBHOOK_SECRET";
const ERP_URL = "https://api.mon-erp.com/orders";
const ERP_TOKEN = "ERP_TOKEN";

// Vérification de la signature HMAC envoyée par Shopify
function isValidShopifyRequest(req) {
  const hmacHeader = req.headers["x-shopify-hmac-sha256"];
  const rawBody = JSON.stringify(req.body);
  const digest = crypto
    .createHmac("sha256", SHOPIFY_WEBHOOK_SECRET)
    .update(rawBody, "utf8")
    .digest("base64");
  return digest === hmacHeader;
}

// Réception du webhook "orders/create"
app.post("/webhooks/orders/create", async (req, res) => {
  if (!isValidShopifyRequest(req)) {
    console.error("Tentative d'appel non autorisée");
    return res.status(401).send("Invalid signature");
  }

  const order = req.body;
  console.log(`📦 Nouvelle commande Shopify : ${order.name}`);

  // 1. On pousse la commande dans l'ERP
  await fetch(ERP_URL, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${ERP_TOKEN}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      external_source: "shopify",
      external_order_id: order.id,
      total_ttc: order.total_price,
      client_email: order.customer.email,
      lignes: order.line_items.map(i => ({
        sku: i.sku,
        qte: i.quantity,
        prix: i.price
      }))
    })
  });

  // 2. Ici on pourrait aussi déclencher un email / Slack / BI

  res.sendStatus(200);
});

app.listen(4000, () => {
  console.log("✅ Middleware Dawap actif sur le port 4000");
});
        

Ce middleware fait office de cerveau d’intégration entre Shopify et vos outils métiers. Il reçoit, nettoie, transforme, sécurise et oriente la donnée. Et surtout : il évite d’exposer directement votre ERP à Shopify.

6️⃣ Architecture cible recommandée

Voici le schéma type qu’on déploie pour un e-commerce sérieux (B2C ou B2B) :

[ Shopify Store ]
      │  (webhooks temps réel : commandes, clients, stocks)
      ▼
[Dawap Middleware API]
      │  (validation HMAC, logs, mapping, sécurité)
      ├─▶ [ERP / WMS]    (stocks, préparation, facturation)
      ├─▶ [CRM]          (profil client, lifetime value)
      └─▶ [Marketing]    (email post-achat, fidélisation)
        

11. Sécurité, conformité et RGPD dans vos intégrations Shopify

Intégrer Shopify avec un ERP, un CRM ou un outil marketing, c’est manipuler de la donnée client hautement sensible : emails, adresses postales, historique d’achat, préférences marketing, parfois même statut de paiement ou TVA. Vous devez donc aborder l’intégration sous deux angles indissociables : la sécurité technique et la conformité RGPD.

1️⃣ Sécuriser l’accès à l’API Shopify

Chaque appel API Shopify demande un Access Token (app privée ou OAuth). Ce token donne accès aux données clients et commandes. Mauvaise gestion du token = fuite de données = vrai risque juridique.

Bon réflexe Dawap : 1 intégration = 1 token dédié. Vous pouvez révoquer une intégration sans casser tout le reste.

2️⃣ Chiffrement et transport sécurisé des données

Les données e-commerce qui transitent (adresse de livraison, email, contenu du panier, montant payé) sont considérées comme données personnelles / transactionnelles.

• HTTPS obligatoire pour tous les échanges (TLS 1.2+). Jamais de HTTP en clair.
• Chiffrement au repos : base de données, backups, exports CSV internes doivent être stockés sur des volumes chiffrés.
• Pas de dump brut des commandes dans un Google Sheet perso / Excel local non sécurisé.
• Pas d’informations clients sensibles copiées dans des canaux publics (Slack général, tickets non protégés, etc.).

3️⃣ Minimisation des données (principe RGPD)

Le RGPD impose un principe fondamental : ne collecter et ne partager que ce qui est strictement nécessaire. Concrètement, lors d’une intégration :

Moralité : on ne “balance pas tout” à tous les outils. Chaque push d’API doit être filtré pour n’envoyer que les champs utiles.

4️⃣ Traçabilité et audit des accès

Vous devez être capable de prouver à tout moment qui a vu quoi, et quand. Ça sert :

Concrètement, côté technique :

• Logger chaque appel critique à l’API Shopify (lecture commande, modification client, suppression).
• Tracer les webhooks reçus (“commande créée”, “remboursement émis”).
• Tracer les synchronisations envoyées à l’ERP / CRM (horodatage, statut HTTP).
• Archiver les changements de statuts commande (payée → expédiée → remboursée).

[2025-10-24 14:31:02] INFO  Sync Shopify → ERP OK (order_id=789123, total=89.90)
[2025-10-24 14:31:04] INFO  Fulfillment pushed to Shopify (tracking=6A1234567890)
[2025-10-24 14:31:06] WARN  Stock update slow (inventory_item_id=987654)
        

5️⃣ Droit d’accès, rectification et suppression (“droit à l’oubli”)

Le RGPD donne à vos clients des droits concrets :

Techniquement, ça veut dire une chose très importante : si vous supprimez un client dans Shopify, vous devez aussi le supprimer / anonymiser dans : l’ERP, le CRM, l’outil marketing, votre BI, etc.

Exemple d’appel API pour supprimer un client Shopify :

DELETE https://{shop}.myshopify.com/admin/api/2025-01/customers/123456.json
X-Shopify-Access-Token: YOUR_ACCESS_TOKEN
        

👉 Cette suppression doit déclencher la même action sur les systèmes connectés. C’est là qu’un middleware Dawap est utile : il orchestre la cohérence RGPD sur tout l’écosystème.

6️⃣ Vos responsabilités légales (DPA / sous-traitants)

Dès que vous partagez les données clients Shopify avec un tiers (ERP SaaS, outil emailing, centre logistique), ce tiers devient un sous-traitant au sens RGPD. Il vous faut donc un DPA (Data Processing Agreement) clair avec lui.

• Vérifier où sont hébergées les données (UE / hors UE).
• Documenter les finalités (“pourquoi on envoie telle donnée à tel outil”).
• Limiter l’accès humain côté prestataire (support technique ≠ accès complet aux clients finaux).
• Mettre à jour le registre de traitement des données personnelles.

12. Monitoring et supervision des intégrations Shopify

Une intégration Shopify n’est pas un “set and forget”. C’est un système vivant : des webhooks peuvent échouer, des tokens expirer, des API ralentir. Pour garantir la fluidité de votre e-commerce, Dawap met l’accent sur un monitoring en temps réel : logs, alertes, supervision, KPIs et visibilité métier. Objectif : anticiper les incidents avant qu’ils n’impactent vos ventes.

1️⃣ Pourquoi monitorer vos intégrations Shopify ?

Une API qui tombe, c’est une commande non transmise, un stock non mis à jour ou un client non relancé. Le monitoring permet d’assurer la continuité de service entre Shopify et vos systèmes connectés.

2️⃣ Les indicateurs clés à suivre

Pour superviser efficacement vos flux Shopify, Dawap recommande de suivre une série de KPI techniques et business.

3️⃣ Exemple de log structuré pour suivi des intégrations

Exemple de log enrichi généré par le middleware Dawap : chaque transaction est tracée avec son statut, temps et type d’intégration.

[2025-10-24 14:21:03] INFO  Shopify webhook received (orders/create, order_id=1054)
[2025-10-24 14:21:04] INFO  Sync → ERP OK (order_id=1054, duration=1.2s)
[2025-10-24 14:21:07] INFO  Fulfillment pushed → Shopify OK (tracking=6A1234567890)
[2025-10-24 14:21:09] WARN  Stock sync delay (SKU=TSHIRT-BLEU-M)
[2025-10-24 14:21:15] ERROR ERP API timeout (endpoint=/orders, retry=2)
        

Ce type de journal permet de détecter les anomalies avant qu’un client ne s’en plaigne. Dawap centralise ces logs dans un tableau de bord visuel.

4️⃣ Monitoring temps réel via dashboard Dawap

Nous proposons des dashboards techniques et métier qui consolident vos flux Shopify ↔ ERP ↔ CRM :

5️⃣ Outils et technologies recommandés

6️⃣ Gestion des alertes et résilience

Un bon monitoring ne sert à rien sans alertes pertinentes et bien calibrées. Dawap met en place un système d’alerte intelligent, basé sur la gravité et la fréquence des incidents.

// Exemple d’alerte Slack via webhook Dawap
await fetch("https://hooks.slack.com/services/XXXX/XXXX/XXXX", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "⚠️ Alerte Shopify: erreur API 500 sur la synchronisation commande #1054",
    attachments: [
      {
        color: "#e74c3c",
        fields: [
          { title: "Système", value: "Shopify Middleware Dawap" },
          { title: "Action", value: "Sync → ERP" },
          { title: "Timestamp", value: new Date().toISOString() }
        ]
      }
    ]
  })
});
        

7️⃣ Exemples de visualisations utiles

Voici quelques exemples de KPIs à afficher dans un dashboard Dawap ou Grafana :

13. Autres solutions du marché

Selon votre modèle (B2C, D2C, B2B, marketplace privée), votre volumétrie et votre niveau d’exigence d’intégration (ERP, PIM, OMS, WMS, marketing automation…), certaines plateformes e-commerce offrent des APIs plus adaptées que d’autres. L’objectif : choisir la bonne base technique, puis la connecter proprement à votre écosystème via des intégrations stables, documentées et scalables.

PrestaShop

PrestaShop est une solution open-source largement utilisée en Europe. Elle expose un Webservice API (REST/XML) permettant de gérer les produits, commandes, clients et stocks. Très personnalisable côté code, elle s’intègre bien avec des ERP, PIM ou outils logistiques via modules ou développement sur mesure. Intéressant pour les marchands qui veulent garder la maîtrise technique et l’hébergement.

Découvrir notre guide PrestaShop

WooCommerce

WooCommerce (WordPress) propose une API REST JSON complète (produits, commandes, taxes, coupons) et une très grande flexibilité via l’écosystème de plugins. Convient bien aux catalogues moyens et aux logiques marketing/agile. Demande toutefois une attention particulière sur la performance, la sécurité et la qualité des extensions dès qu’on commence à connecter ERP, logistique ou marketplaces.

Découvrir notre guide WooCommerce

Magento / Adobe Commerce

Magento (Adobe Commerce) est pensé pour les architectures complexes, multi-catalogues, multi-boutiques, B2B/B2C. APIs REST et GraphQL très riches, gestion fine des prix, droits d’accès, règles business avancées. S’intègre profondément à l’ERP, au PIM ou à l’OMS via un middleware ou des bus d’événements. Puissant, mais nécessite une équipe technique solide et une gouvernance claire.

Découvrir notre guide Magento / Adobe Commerce

BigCommerce

BigCommerce adopte une approche “API-first / headless”. Les APIs (REST, GraphQL) couvrent tout le cycle e-commerce, avec une orientation forte omnicanale et intégration ERP / OMS / PIM standardisée. Pertinent pour les marques qui veulent un front personnalisé (Next.js, Vue Storefront…) et une couche commerce pilotée par API plutôt qu’un monolithe traditionnel.

Découvrir notre guide BigCommerce

Shopware

Shopware (notamment les dernières versions headless / PWA-ready) propose une architecture moderne, orientée expérience produit et storytelling. APIs REST et GraphQL, logique B2B avancée, et ouverture vers des architectures composables (PIM, CMS headless, moteur de pricing dynamique). Intéressant pour des parcours e-commerce sur-mesure ou premium.

Découvrir notre guide Shopware

Chaque plateforme a ses forces mais aussi ses contraintes d’intégration. L’enjeu n’est pas seulement de “lancer une boutique”, mais de construire un socle capable de dialoguer proprement avec votre SI, vos canaux marketing et vos partenaires logistiques — sans dette technique immédiate.