# Make Agent Fast documentation (fr)

---

# Journal des modifications

Source: /fr/docs/account/changelog.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Plateforme&#x22;, icon: &#x22;spark&#x22; }, { label: &#x22;API&#x22;, icon: &#x22;code&#x22; }, { label: &#x22;Documentation&#x22;, icon: &#x22;book&#x22; }]" />

## 2026-08-27 [#2026-08-27]

* Documentation du lancement d'un agent à partir d'une URL : attente pendant la génération, **Review & publish**, **Approve & publish**, et activation dès la première conversation ou le premier lead d'un visiteur.
* Documentation de l'option d'apparence **Use website** par rapport à Light/Dark, et du fait que l'enregistrement de l'apparence met à jour l'intégration en direct (ainsi que les éventuelles pages hébergées restantes) sans nouvelle publication.
* Alignement des extraits d'intégration sur les attributs actuels de `embed.js` et sur le paramètre anti-cache `?v=` du tableau de bord.
* Documentation de la conversation vocale en direct dans le testeur de la plateforme par rapport au site publié et à l'intégration.
* Suppression du domaine personnalisé, de l'achat de domaine et des paramètres de sous-domaine en tant que fonctionnalités du produit. Intégrez l'agent sur le site web existant de votre client. Les événements résiduels liés au module complémentaire de domaine Polar restent ignorés ou annulés.

## 2026-07-28 [#2026-07-28]

* Simplification de l'historique d'utilisation : il affiche désormais les crédits finalement consommés au lieu de lignes distinctes de réservation et de remboursement ; les très faibles consommations s'affichent sous la forme `<0.001`.
* Les coins de la sélection dans le menu d'actions de la documentation s'adaptent désormais aux contenus multilignes, tout en conservant une géométrie identique entre le déclencheur et l'enveloppe du menu.
* Enrichissement des guides en anglais, en coréen et en ouzbek : facturation des appels en direct, saisie de médias dans le créateur visuel, modifications du sous-domaine hébergé, contrôles de confidentialité et de sécurité du compte, et flux d'événements des notifications.

## 2026-07-15 [#2026-07-15]

* Lancement de la plateforme de documentation bilingue de Make Agent Fast.
* Ajout, pour chaque page, du Markdown, des téléchargements, de la recherche et des actions ChatGPT et Claude.
* Ajout de `/docs/llms.txt`, de `/docs/llms-full.txt` et des routes `.md` canoniques.
* Documentation de l'API publique, du contrat du SDK, des webhooks, des intégrations, des connecteurs, de l'exploitation, de la tarification, de la sécurité et de la confidentialité.
* Ajout de guides de mise en œuvre pour les principaux frameworks et créateurs de sites web.

## Politique de versionnement [#politique-de-versionnement]

Les corrections de la documentation et les ajouts de champs à l'API peuvent être publiés en continu. Toute modification majeure de l'API publique nécessite un nouveau chemin majeur ou une période de migration documentée.

---

# Offres et tarifs

Source: /fr/docs/account/pricing.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ label: &#x22;Launch&#x22;, icon: &#x22;layers&#x22; },
{ label: &#x22;Operate&#x22;, icon: &#x22;spark&#x22; },
{ label: &#x22;Scale&#x22;, icon: &#x22;bolt&#x22; },
{ label: &#x22;Packs de crédits&#x22;, icon: &#x22;layers&#x22; }
]"
/>

<TutorialVideo episode="ep08" start="132" />

## Comparatif des offres [#comparatif-des-offres]

| Offre   | Facturation mensuelle | Total annuel | Crédits mensuels |                                     Agents | Voix en direct | Badge de marque |
| ------- | --------------------: | -----------: | ---------------: | -----------------------------------------: | -------------: | --------------- |
| Launch  |             15 $/mois |     144 $/an |             1000 |                                          1 |    Non incluse | Obligatoire     |
| Operate |             35 $/mois |     336 $/an |             3000 |                                          3 |    30 min/mois | Amovible        |
| Scale   |             79 $/mois |     758 $/an |             8000 | Illimité, sous réserve d'usage raisonnable |    90 min/mois | Amovible        |

La facturation annuelle revient à 20 % de moins que douze paiements au tarif mensuel. Launch et Operate commencent par un essai gratuit de sept jours, sans carte bancaire ; ajoutez une carte après le jour 7 pour que l'agent reste en ligne. Scale est facturée dès le départ et ne comporte pas d'essai. Lorsqu'une carte est requise, la page de paiement affiche le prix exact, la période de renouvellement, les taxes et les conditions avant l'achat.

Launch vous donne un agent intégré opérationnel dès cette semaine. Operate est l'étape suivante lorsque vos clients commencent réellement à échanger : voix en direct, widget plus complet et canaux de messagerie. Scale est le studio complet : tous les contrôles Look, des rôles pour l'équipe et vos propres clés de fournisseur.

## Échelle des fonctionnalités [#échelle-des-fonctionnalités]

| Fonctionnalité              | Launch                                              | Operate                                                     | Scale                                                           |
| --------------------------- | --------------------------------------------------- | ----------------------------------------------------------- | --------------------------------------------------------------- |
| Agents                      | 1                                                   | 3                                                           | Illimité, sous réserve d'usage raisonnable                      |
| Studio du widget            | Couleur d'accent, position, clair/sombre            | + libellé du lanceur, préréglages, couleurs supplémentaires | Tous les contrôles (rayon, ombre, bordure, police, effet verre) |
| Langues de la voix          | 1                                                   | 2                                                           | Toutes les langues prises en charge                             |
| Ingestion des connaissances | Texte collé, URL, fichiers                          | + YouTube, podcast, RSS                                     | Identique à Operate                                             |
| Canaux de messagerie        | Les connexions existantes continuent de fonctionner | Nouvelles connexions                                        | Nouvelles connexions                                            |
| Clés personnelles (BYOK)    | Les clés existantes continuent de fonctionner       | Les clés existantes continuent de fonctionner               | Enregistrement de nouvelles clés                                |
| Invitations d'équipe        | Les membres existants restent                       | Les membres existants restent                               | Nouvelles invitations avec rôles                                |

Nous ne vendons ni ne rattachons de noms de domaine à nos clients. Intégrez l'agent sur le site web que vous possédez déjà.

## Inclus dans toutes les offres [#inclus-dans-toutes-les-offres]

Toutes les offres actuelles comprennent :

* Une intégration sur le site web que vous possédez déjà (`embed.js` + `data-agent`).
* Le chat textuel, les messages vocaux, les voix prédéfinies, la recherche dans les connaissances, les FAQ et produits structurés, ainsi que la capture de leads.
* L'intégration sur un site web avec contrôle précis des origines autorisées.
* L'accès à l'API publique avec des clés à portée limitée, OAuth pour les applications validées, OpenAPI et des limites de débit proportionnelles à l'offre.
* Les statistiques, les conversations, le suivi de l'utilisation et la possibilité d'acheter des packs de crédits.

Le quota de l'API publique est de 120 requêtes par clé d'API et par minute pour Launch, 600 pour Operate et 1 800 pour Scale. Ces limites de requêtes ne remplacent pas les droits liés aux ressources, les vérifications de crédits, l'idempotence ni les limites propres aux fournisseurs. Consultez [Limites de débit](/fr/docs/api/rate-limits).

## Comprendre les crédits [#comprendre-les-crédits]

Les crédits servent à payer les tâches d'IA mesurées, telles que la génération, les tours de l'agent, les embeddings des connaissances, la transcription et la synthèse vocale. Ils ne correspondent pas à un nombre fixe de messages : le fournisseur, le modèle, la longueur des entrées et des sorties, la durée des médias et le type d'opération font varier le coût.

Les crédits mensuels de l'offre sont renouvelés à chaque période de facturation. Le solde mensuel inutilisé est reporté pour un cycle supplémentaire, puis expire. Les crédits de recharge achetés n'expirent pas tant qu'un abonnement est actif. Un solde de crédits positif ne débloque pas une fonctionnalité réservée à certaines offres, comme les appels en direct, les sites supplémentaires ou la suppression du badge.

Les clés de fournisseur personnelles (BYOK) entraînent des frais distincts facturés par OpenRouter (texte) ou Speko (voix), les deux fournisseurs pour lesquels une nouvelle clé peut être ajoutée ; les anciennes clés de fournisseurs directs déjà enregistrées continuent de fonctionner jusqu'à leur révocation. L'enregistrement d'une clé est réservé à Scale. Avec votre propre clé, chaque action coûte des frais de plateforme forfaitaires (1 crédit par réponse de chat) au lieu d'une facturation basée sur les tokens. Le BYOK ne convertit pas les factures des fournisseurs en crédits Make Agent Fast et ne supprime pas les vérifications de droits de la plateforme. Consultez [Clés de fournisseur d'IA](/fr/docs/account/provider-keys).

## Droits liés à la voix [#droits-liés-à-la-voix]

Les messages vocaux sont inclus dans toutes les offres, mais leur transcription, leur modèle et leur synthèse vocale peuvent consommer des crédits. La voix en temps réel en direct utilise un quota mensuel de minutes distinct : aucune sur Launch, 30 minutes sur Operate et 90 minutes sur Scale.

## Agents et marque [#agents-et-marque]

Launch prend en charge un agent destiné aux clients, et Operate jusqu'à trois. La description « agents illimités » de Scale est soumise à un usage raisonnable : elle n'autorise pas la création abusive ou automatisée d'un volume de tenants. Un agent comprend ses connaissances, sa configuration d'intégration, ses connecteurs, ses statistiques et ses données de conversation. Chaque agent dispose d'un Agent link, une page de chat publique hébergée sur son propre sous-domaine. Les anciennes pages de démonstration hébergées continuent de s'afficher sur des sous-domaines ; les nouveaux agents n'obtiennent pas de page marketing hébergée.

Le badge de parrainage « Made with Make Agent Fast » reste affiché sur Launch. Les owners des offres Operate et Scale peuvent le retirer des sites publiés éligibles.

## Packs de crédits [#packs-de-crédits]

| Achat      |             Prix | Effet                                                                    |
| ---------- | ---------------: | ------------------------------------------------------------------------ |
| Petit pack |  8 $ en une fois | Ajoute 1000 crédits qui n'expirent pas tant que l'abonnement est actif   |
| Pack moyen | 35 $ en une fois | Ajoute 5000 crédits qui n'expirent pas tant que l'abonnement est actif   |
| Grand pack | 90 $ en une fois | Ajoute 15 000 crédits qui n'expirent pas tant que l'abonnement est actif |

Les recharges ajoutent uniquement de la capacité d'utilisation. Elles n'augmentent ni le nombre de sites, ni les limites de requêtes de l'API, ni les minutes en direct, ni les droits liés à la marque.

## Essais, renouvellement et résiliation [#essais-renouvellement-et-résiliation]

L'essai gratuit de Launch et Operate ne se convertit pas automatiquement : au jour 7, l'agent est mis en pause jusqu'à ce que vous ajoutiez une carte. Une fois une carte enregistrée, une résiliation ou un échec de renouvellement peut entraîner la suppression de l'accès actif après la période ou la transition de statut applicable chez le fournisseur. Les intégrations, les connecteurs, les clients API et les appels vocaux peuvent s'arrêter, même si les données enregistrées de l'espace de travail sont conservées.

## Choisir une offre [#choisir-une-offre]

* Choisissez **Launch** pour un agent intégré avec chat textuel, messages vocaux et widget de base.
* Choisissez **Operate** lorsque vos clients commencent à échanger : appels en direct, canaux de messagerie, widget personnalisé, voix en deux langues ou suppression du badge.
* Choisissez **Scale** lorsque plusieurs agents sont en production : tous les contrôles du widget, la voix dans toutes les langues prises en charge, des rôles pour l'équipe et vos propres clés d'API.

Faites vos estimations à partir de véritables tests d'acceptation, plutôt qu'en vous basant uniquement sur le nombre de messages. Publiez un agent représentatif, mesurez l'utilisation du texte, de la voix et des connaissances, puis projetez le trafic et prévoyez une marge pour les nouvelles tentatives, les connecteurs, l'automatisation et les pics de lancement.

## Source de référence pour la facturation [#source-de-référence-pour-la-facturation]

La page de paiement en direct et le tableau de bord de facturation font foi pour un achat donné. Les taxes, l'affichage de la devise, les moyens de paiement, l'éligibilité à l'essai et la formulation du fournisseur peuvent varier selon le lieu et l'état du compte. Si la page de paiement diffère de cette page, arrêtez-vous et appliquez les conditions de la page de paiement, ou contactez le support avant de payer.

---

# Confidentialité et données

Source: /fr/docs/account/privacy.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Données des visiteurs&#x22;, icon: &#x22;account&#x22; }, { label: &#x22;Conservation&#x22;, icon: &#x22;book&#x22; }, { label: &#x22;Contrôles&#x22;, icon: &#x22;shield&#x22; }]" />

Le propriétaire du site décide quelles connaissances, quelles saisies de visiteurs et quelles intégrations sont utilisées pour son expérience. Make Agent Fast traite les données de la plateforme afin de fournir le service, conformément aux conditions applicables et à l'avis de confidentialité.

## Mention destinée aux visiteurs [#mention-destinée-aux-visiteurs]

Expliquez l'utilisation de l'IA, l'enregistrement, la collecte de leads, les analyses et le suivi dans un langage adapté à l'expérience proposée et aux exigences locales. Ne demandez pas à l'agent de collecter des données dont vous n'avez pas besoin.

## Cycle de vie des données [#cycle-de-vie-des-données]

La suppression d'une source n'affecte que les recherches futures. La suppression d'un identifiant coupe l'accès autorisé. Les conversations passées, les exports, les données des canaux externes et les enregistrements des fournisseurs peuvent avoir des règles de conservation distinctes.

## Contrôles du propriétaire [#contrôles-du-propriétaire]

La page **Analytique** du site permet d'exporter les leads collectés au format JSON et de supprimer un lead individuel. Les rapports d'analyse peuvent également être exportés au format Markdown, Excel ou dans une vue d'impression/PDF. Un export crée une nouvelle copie que vous contrôlez ; la suppression de l'enregistrement sur la plateforme n'efface pas un téléchargement antérieur, une conversation associée, un enregistrement chez un fournisseur externe ni des données conservées en vertu d'une obligation légale.

Utilisez les **Paramètres du compte** pour déconnecter tous les appareils ou supprimer définitivement le compte. La suppression du compte tente d'abord d'arrêter l'abonnement à la plateforme, les abonnements complémentaires de domaine Polar restants et les ressources des connecteurs, puis supprime les sites, agents, connaissances, conversations, leads, identifiants API/OAuth, sessions et l'historique de facturation stocké localement du compte. Si l'arrêt de la facturation externe ne peut pas être confirmé, la suppression échoue par mesure de sécurité et laisse le compte intact afin de permettre une nouvelle tentative en toute sécurité ou un examen par le support.

## Demandes [#demandes]

Utilisez les contrôles en libre-service lorsqu'ils correspondent à la demande. Pour une demande plus large d'accès, de rectification, d'export ou de suppression, contactez le support du compte et suivez la procédure décrite dans la Politique de confidentialité en vigueur. Vérifiez l'identité du demandeur avant de divulguer des données du compte, et incluez les exports en aval et les fournisseurs externes dans votre plan de réponse.

---

# Clés de fournisseurs d'IA

Source: /fr/docs/account/provider-keys.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;spark&#x22;, title: &#x22;Génération de texte&#x22;, description: &#x22;Une seule clé OpenRouter finance la génération de texte de l'agent sur l'ensemble de ses modèles.&#x22; },
{ icon: &#x22;voice&#x22;, title: &#x22;Voix&#x22;, description: &#x22;Une seule clé Speko finance la transcription et la synthèse vocale.&#x22; },
{ icon: &#x22;shield&#x22;, title: &#x22;Stockage chiffré&#x22;, description: &#x22;Les clés complètes sont chiffrées et ne sont jamais renvoyées après l'enregistrement.&#x22; }
]"
/>

Le principe « apportez votre propre clé » (BYOK) permet aux requêtes d'IA prises en charge d'utiliser votre compte auprès du fournisseur d'IA. Vous n'avez pas besoin de clé : la plateforme fournit les modèles par défaut. L'enregistrement d'une clé nécessite le plan Scale. Les clés déjà enregistrées continuent de fonctionner sur Launch et Operate. Vous payez toujours le plan Make Agent Fast ainsi que des frais de plateforme forfaitaires par action ; le fournisseur facture directement l'utilisation de ses modèles à votre compte.

## Fournisseurs pris en charge [#fournisseurs-pris-en-charge]

De nouvelles clés ne peuvent être ajoutées que pour deux fournisseurs, l'un pour le texte et l'autre pour la voix :

| Fournisseur | Utilisation                                                                                | Créer ou consulter une clé                        |
| ----------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------- |
| OpenRouter  | Génération de texte de l'agent via les modèles vers lesquels OpenRouter route les requêtes | [Clés API OpenRouter](https://openrouter.ai/keys) |
| Speko       | Reconnaissance vocale (speech-to-text) et synthèse vocale (text-to-speech)                 | [Plateforme Speko](https://platform.speko.ai)     |

### Clés héritées [#clés-héritées]

Les clés directes des fournisseurs enregistrées avant le passage à OpenRouter et Speko apparaissent sous **Clés héritées**. Elles continuent de fonctionner jusqu'à ce que vous les révoquiez, et vous pouvez toujours les révoquer, mais vous ne pouvez plus en ajouter ni en remplacer :

| Fournisseur hérité                              | Utilisation                                                             | Référence du fournisseur                                                                                                                                                                                                                      |
| ----------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Anthropic, OpenAI, Google Gemini, xAI, DeepSeek | Génération de texte de l'agent                                          | [Documentation de l'API Anthropic](https://platform.claude.com/docs/en/api/overview), [Démarrage rapide de l'API OpenAI](https://developers.openai.com/api/docs/quickstart), [Clés API Gemini](https://ai.google.dev/gemini-api/docs/api-key) |
| Deepgram                                        | Reconnaissance vocale lorsque Deepgram est le fournisseur STT configuré | [Clés API Deepgram](https://developers.deepgram.com/docs/create-additional-api-keys)                                                                                                                                                          |
| ElevenLabs                                      | Synthèse vocale lorsque ElevenLabs est configuré                        | [Authentification ElevenLabs](https://elevenlabs.io/docs/api-reference/authentication)                                                                                                                                                        |

La disponibilité des fournisseurs dépend également des fournisseurs de texte, de voix et de temps réel configurés sur la plateforme. L'enregistrement d'une clé valide n'oblige pas chaque fonctionnalité à utiliser ce fournisseur.

<Callout title="Le BYOK est différent d'une clé API Make Agent Fast">
  Une clé de fournisseur autorise les facturations et les appels de modèles chez le fournisseur d'IA externe. Une clé `maf_live_...` autorise votre logiciel à appeler l'API publique de Make Agent Fast. Ne collez jamais l'une dans le champ de l'autre.
</Callout>

## Ajouter une clé de fournisseur [#ajouter-une-clé-de-fournisseur]

1. Créez une clé dans la console OpenRouter ou Speko et activez la facturation du fournisseur ou une limite de dépenses si nécessaire.
2. Ouvrez **Tableau de bord → Paramètres → Clés de fournisseurs d'IA**. Seul le propriétaire de la facturation d'un espace de travail Scale peut enregistrer une clé.
3. Collez la clé dans la carte **OpenRouter** ou **Speko**.
4. Sélectionnez **Tester et enregistrer**.
5. Attendez le résultat de la validation, puis testez la fonctionnalité qui utilise le fournisseur.

Make Agent Fast effectue une requête de validation en direct avant d'enregistrer une clé ; aucun jeton de modèle ni crédit de la plateforme n'est consommé. La clé ne doit contenir ni espaces ni sauts de ligne et doit comporter entre 16 et 512 caractères. Les clés OpenRouter doivent commencer par `sk-or-` ; les clés Speko doivent commencer par `sk_speko_` ou `sk_live_`. La validation en direct fait foi.

L'enregistrement d'une autre clé fonctionnelle pour le même fournisseur remplace la valeur précédemment stockée. Une clé qui échoue à la validation n'est pas enregistrée ; la clé déjà en place continue donc de fonctionner. Le tableau de bord ne conserve que des données d'identification sûres, telles que les quatre derniers caractères, la date de validation et l'état.

## Fonctionnement de la sélection du fournisseur de texte [#fonctionnement-de-la-sélection-du-fournisseur-de-texte]

Pour la génération de texte, une clé OpenRouter active est prioritaire. À défaut, Make Agent Fast recherche une clé héritée active correspondant au fournisseur de texte configuré sur la plateforme, puis les autres clés de texte héritées (Anthropic, OpenAI, Gemini, xAI, DeepSeek) dans cet ordre. Si aucune clé BYOK adaptée n'existe, il utilise le fournisseur de la plateforme lorsque le plan et le déploiement le permettent.

Les clés de voix sont propres à chaque fournisseur. Une clé Speko est utilisée lorsque la voix passe par Speko. Une clé Deepgram héritée n'est utilisée que lorsque le fournisseur de reconnaissance vocale actif est Deepgram ; une clé ElevenLabs héritée n'est utilisée que lorsque la synthèse vocale est configurée sur ElevenLabs.

Les clés BYOK ne remplacent pas pour l'instant les identifiants d'embeddings de connaissances de la plateforme. L'ingestion et la récupération des connaissances continuent d'utiliser le fournisseur d'embeddings configuré pour le déploiement.

## Facturation et crédits [#facturation-et-crédits]

* Le fournisseur externe facture la consommation de jetons d'IA au compte qui a émis la clé.
* Make Agent Fast facture toujours l'abonnement ainsi que des frais de plateforme forfaitaires pour chaque action exécutée avec votre clé : 1 crédit par réponse de chat, au lieu de la facturation basée sur les jetons. Ces frais couvrent la récupération, l'orchestration et l'hébergement autour de l'appel, et ne représentent pas un pourcentage de votre facture de jetons.
* Les frais s'appliquent à chaque appel au fournisseur. Les étapes vocales financées par la plateforme (par exemple, la transcription lorsque vous n'avez qu'une clé de texte) sont facturées au tarif normal, et les appels en direct utilisent toujours le tarif de la plateforme.
* L'épuisement du quota du fournisseur peut faire échouer une requête même s'il reste des crédits Make Agent Fast.

Consultez à la fois **Utilisation et crédits** dans Make Agent Fast et le tableau de bord d'utilisation du fournisseur.

## États des clés et gestion des échecs [#états-des-clés-et-gestion-des-échecs]

| État      | Signification                                       | Que faire                                                                                                                                                       |
| --------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `active`  | La validation en direct a réussi                    | Testez la fonctionnalité visée et surveillez l'utilisation côté fournisseur                                                                                     |
| `invalid` | Le fournisseur a rejeté la clé stockée par la suite | Vérifiez la facturation, les restrictions, le quota et l'état de révocation chez le fournisseur, puis enregistrez une clé de remplacement (OpenRouter ou Speko) |
| `revoked` | La clé est désactivée dans Make Agent Fast          | Enregistrez une nouvelle clé OpenRouter ou Speko si la fonctionnalité doit continuer à utiliser le BYOK                                                         |

Si une requête échoue parce qu'un fournisseur rejette l'identifiant ou le quota, Make Agent Fast peut marquer la clé stockée comme invalide. Corriger la clé chez le fournisseur ne révèle ni ne réécrit le secret stocké ; pour une clé OpenRouter ou Speko, utilisez **Tester la connexion** pour la revérifier, ou enregistrez à nouveau la clé fonctionnelle. Une clé héritée devenue invalide ne peut pas être remplacée par une autre clé héritée : migrez plutôt ce fournisseur vers OpenRouter ou Speko.

## Renouveler une clé de fournisseur [#renouveler-une-clé-de-fournisseur]

1. Créez une nouvelle clé chez le fournisseur sans supprimer l'ancienne.
2. Enregistrez la nouvelle clé dans Make Agent Fast et vérifiez qu'elle devient active.
3. Testez le chat texte ou les messages vocaux, selon ce qui utilise ce fournisseur.
4. Révoquez l'ancienne clé dans la console du fournisseur.
5. Consultez les journaux du fournisseur pour détecter toute utilisation inattendue de l'ancienne clé.

Si une clé est exposée dans un système de gestion de versions ou dans du code navigateur, révoquez-la immédiatement chez le fournisseur. La supprimer uniquement de Make Agent Fast n'empêche pas une autre personne qui la détient de l'utiliser directement auprès du fournisseur.

---

# Sécurité

Source: /fr/docs/account/security.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;shield&#x22;, title: &#x22;Identifiants&#x22;, description: &#x22;Les clés, secrets OAuth et jetons de connecteur restent côté serveur.&#x22; },
{ icon: &#x22;embed&#x22;, title: &#x22;Listes d'origines autorisées pour l'embed&#x22;, description: &#x22;Contrôlez quelles origines peuvent charger le widget de votre agent.&#x22; },
{ icon: &#x22;link&#x22;, title: &#x22;Webhooks&#x22;, description: &#x22;Vérifiez les signatures avant de faire confiance aux événements entrants.&#x22; }
]"
/>

## Accès au compte [#accès-au-compte]

Utilisez un mot de passe unique, protégez la messagerie utilisée pour la récupération du compte, mettez fin aux sessions que vous ne reconnaissez pas et limitez l'accès aux sites de production.

Vérifiez l'adresse e-mail du compte à l'aide du lien envoyé après l'inscription. Les comptes avec mot de passe peuvent utiliser **Mot de passe oublié** sur la page de connexion ; une réinitialisation réussie révoque les sessions existantes. Les **Paramètres du compte** permettent de modifier un mot de passe local, de lier explicitement Google lorsque cette option est activée et de déconnecter tous les appareils. Les comptes OAuth uniquement n'ont pas de mot de passe local à modifier, et une connexion normale ne lie jamais silencieusement une nouvelle identité.

## Secrets [#secrets]

Les clés API, jetons de connecteur, secrets d'application, secrets de webhook et clés de fournisseur vocal sont des identifiants. Stockez-les dans un gestionnaire de secrets approuvé, jamais dans le code côté client, et renouvelez-les après toute exposition.

## Principe du moindre privilège [#principe-du-moindre-privilège]

Choisissez des portées d'API restreintes, des applications dédiées sur les plateformes externes, des origines d'embed précises et des clés distinctes pour chaque système. Supprimez les identifiants et les intégrations inutilisés.

## Contenu et confidentialité [#contenu-et-confidentialité]

Importez uniquement les données que l'agent est autorisé à utiliser. Testez les refus et les parcours d'escalade, et appliquez des règles de conservation aux exports de conversations et de leads.

## Signalement [#signalement]

Lorsque vous signalez une vulnérabilité présumée, indiquez l'URL ou le composant concerné, l'impact et les étapes de reproduction, sans accéder aux données d'autres utilisateurs.

---

# Dépannage

Source: /fr/docs/account/troubleshooting.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Publier&#x22;, icon: &#x22;globe&#x22; }, { label: &#x22;Intégrer&#x22;, icon: &#x22;embed&#x22; }, { label: &#x22;Connecteurs&#x22;, icon: &#x22;connectors&#x22; }]" />

## Commencez par un cas reproductible [#commencez-par-un-cas-reproductible]

Avant de modifier les paramètres, notez :

* L'espace de travail/le site, la route publique ou le point de terminaison de l'API, ainsi que l'heure exacte avec le fuseau horaire.
* Le résultat attendu et le résultat obtenu.
* Le navigateur/l'appareil ou le canal du fournisseur externe.
* Si le problème touche l'aperçu du owner, la page de démonstration hébergée résiduelle, l'intégration, le connecteur et/ou l'API.
* Le texte d'état/d'erreur sans risque, l'en-tête de réponse `x-request-id`, la dernière erreur du connecteur ou l'ID d'événement de livraison du fournisseur.
* La dernière heure de bon fonctionnement connue et la plus petite modification récente.

N'incluez pas d'identifiants d'API/de fournisseur/de connecteur en clair, de secrets de webhook, de données privées de customers, d'en-têtes d'autorisation complets ni de contenu de conversation superflu.

## Les modifications du site n'apparaissent pas [#les-modifications-du-site-napparaissent-pas]

1. Vérifiez que l'URL du tableau de bord correspond bien au site et à l'espace de travail prévus.
2. Vérifiez que l'action d'enregistrement a bien indiqué un succès.
3. Les instructions et les connaissances indexées s'appliquent aux nouvelles conversations sans nouvelle publication. Si le widget lui-même est masqué, réactivez-le depuis le menu **Mettre en ligne** de la page de l'agent → **Widget de site web** (ou depuis la carte **Sur votre site web** de l'onglet **Vue d'ensemble**).
4. Pour les paramètres d'**Affichage** (et le badge de marque), les modifications sont enregistrées automatiquement et actualisent déjà l'intégration en ligne : inutile de republier, ouvrez simplement une fenêtre de navigation privée.
5. Ouvrez une véritable intégration (ou un slug hébergé résiduel, si vous en avez encore un) dans une fenêtre de navigation privée.
6. Si seul un aperçu sur les réseaux sociaux est périmé, utilisez le cache/l'outil de débogage de cette plateforme.

Dépublier et modifier sont deux choses différentes. Un connecteur de messagerie connecté peut continuer à répondre même lorsque l'intégration est désactivée.

## La réponse de l'agent est faible ou erronée [#la-réponse-de-lagent-est-faible-ou-erronée]

Posez la même question dans le testeur du owner et dans une nouvelle conversation publique. Vérifiez que la source de connaissances concernée a été indexée, qu'elle contient une réponse explicite, qu'elle est à jour et qu'elle n'entre pas en conflit avec une autre source. Examinez les règles de langue/de persona pour détecter une limite qui empêcherait la réponse.

Lorsque la source ne contient pas de réponse, améliorez le comportement de repli/d'escalade plutôt que de demander à l'agent de deviner. Utilisez [Sources de connaissances](/fr/docs/build/knowledge) pour créer un jeu de validation avec des questions directes, des paraphrases et des cas limites.

## Le lanceur d'intégration est absent ou bloqué [#le-lanceur-dintégration-est-absent-ou-bloqué]

Vérifiez que le site est publié, que l'intégration est activée, que le script contient le slug exact du site et que l'origine parente finale du navigateur (schéma, nom d'hôte et port compris) figure dans la liste d'autorisation. Dans les DevTools, inspectez la requête `embed.js`, les erreurs CSP, l'état du gestionnaire de consentement, la requête de l'iframe et la présence d'une seule racine `data-maf-embed`.

Si le texte fonctionne mais pas le microphone, vérifiez le HTTPS, l'autorisation du navigateur, l'autorisation `allow` de l'iframe et la Permissions Policy de l'hôte. Suivez la [Présentation de l'intégration](/fr/docs/embed/overview) complète ainsi que [Sécurité et CSP](/fr/docs/embed/security).

## La voix ne fonctionne pas [#la-voix-ne-fonctionne-pas]

Distinguez le mode en échec : message vocal, appel en direct ou voix via un connecteur. Un parcours texte fonctionnel prouve uniquement que la clé du modèle de langage est valide.

Vérifiez séparément les clés des fournisseurs de transcription, de synthèse vocale (TTS) et de temps réel ; vérifiez ensuite les droits du forfait, le solde de credits, le quota de minutes en direct, l'autorisation du navigateur et les langues configurées. Testez un enregistrement court et clair avant d'étudier un fichier long ou bruité.

## Le connecteur ne reçoit aucun message [#le-connecteur-ne-reçoit-aucun-message]

Utilisez le guide du canal et comparez les deux côtés. Vérifiez que le connecteur est activé, que les identifiants sont toujours valides, que l'URL de webhook/d'interaction/de skill du fournisseur est bien l'URL actuelle, que l'événement/la Page/le numéro/le bloc requis est abonné, que le mode de l'application inclut l'utilisateur de test et que la livraison HTTPS publique fonctionne.

Le succès de la vérification du webhook ne prouve pas l'abonnement aux événements à l'exécution ni les autorisations d'envoi. Comparez les journaux de livraison du fournisseur avec **Dernier message** et l'erreur enregistrée du connecteur. Testez le texte avant la voix.

## Les domaines personnalisés ne sont pas proposés [#les-domaines-personnalisés-ne-sont-pas-proposés]

Nous ne vendons ni ne rattachons de domaines de customers. Placez l'agent sur le site que vous possédez déjà grâce à l'[intégration](/fr/docs/embed/overview). Les événements résiduels de module complémentaire de domaine Polar sont ignorés ou annulés et ne génèrent jamais de credits.

## La requête API échoue [#la-requête-api-échoue]

Notez la méthode, le chemin versionné, le statut, le code d'erreur stable, l'en-tête de réponse `x-request-id` et les en-têtes de limite de débit pertinents. Classez ensuite le problème :

| Statut | Action la plus probable                                                                                            |
| ------ | ------------------------------------------------------------------------------------------------------------------ |
| `400`  | Corrigez la structure JSON/du formulaire ou les détails de validation ; ne réessayez pas à l'identique             |
| `401`  | Utilisez un identifiant MAF valide, non expiré et non révoqué ; n'utilisez jamais une clé de fournisseur           |
| `403`  | Ajoutez le scope requis ou rétablissez l'accès au forfait/à la ressource                                           |
| `404`  | Vérifiez que l'ID appartient à l'espace de travail authentifié et que le chemin est correct                        |
| `409`  | Résolvez le conflit d'état ou rejouez la même clé d'idempotence/le même payload                                    |
| `415`  | Envoyez le type de contenu documenté                                                                               |
| `429`  | Respectez les en-têtes `retry-after`/de réinitialisation avec une part d'aléa (jitter) ; ne bouclez pas en continu |
| `500`  | Réessayez une requête sûre/idempotente et conservez l'ID de requête et l'heure                                     |

Consultez [Identifiants et jetons](/fr/docs/api/credentials), [Scopes et erreurs](/fr/docs/api/scopes-errors) et [Limites de débit](/fr/docs/api/rate-limits). Ne résolvez jamais une erreur d'API en déplaçant un identifiant serveur dans du code navigateur.

## La facturation ou l'utilisation semble incorrecte [#la-facturation-ou-lutilisation-semble-incorrecte]

Distinguez l'accès à la plateforme, les credits mensuels, les credits achetés, le nombre de sites, les minutes en direct, le débit de l'API, les canaux de messagerie (Operate+) et le BYOK/les team members (Scale). Une recharge ne modifie que les credits. Les frais du fournisseur BYOK sont distincts de la facturation de Make Agent Fast.

En cas d'utilisation inattendue, circonscrivez la source probable avant d'enquêter : désactivez un connecteur, révoquez une clé, supprimez une origine d'intégration involontaire ou arrêtez une boucle de nouvelles tentatives de l'API. Conservez la plage horaire et les ID de requête/de fournisseur sans exposer de secrets.

## Rassembler des informations sûres pour le support [#rassembler-des-informations-sûres-pour-le-support]

Si vous êtes toujours bloqué, utilisez le contrôle de feedback du guide le plus pertinent ou contactez le support depuis le tableau de bord en indiquant :

* L'identifiant du site/de l'espace de travail et la fonctionnalité concernée.
* L'horodatage exact avec le fuseau horaire et les étapes de reproduction.
* Le résultat attendu et le résultat obtenu.
* L'URL publique sans secret, le cas échéant.
* Le statut HTTP, le code d'erreur stable, le `x-request-id` ou l'ID d'événement du fournisseur.
* Une capture d'écran expurgée ou un payload minimal dont les secrets et les données personnelles ont été retirés.

Indiquez ce que vous avez déjà vérifié. Cela évite de répéter des conseils de configuration et permet de délimiter clairement la source de la défaillance.

---

# Authentification

Source: /fr/docs/api/authentication.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;shield&#x22;, title: &#x22;Clés API&#x22;, description: &#x22;Identifiants bearer à portée limitée, pour un seul compte et un serveur que vous contrôlez.&#x22; },
{ icon: &#x22;account&#x22;, title: &#x22;OAuth&#x22;, description: &#x22;Autorisation validée pour les applications qui se connectent à plusieurs comptes clients.&#x22; },
{ icon: &#x22;layers&#x22;, title: &#x22;Moindre privilège&#x22;, description: &#x22;Chaque opération indique la portée exacte en lecture ou en écriture dont elle a besoin.&#x22; }
]"
/>

Utilisez une clé API pour votre propre backend ou vos automatisations. Utilisez OAuth lorsque votre application demande à d'autres utilisateurs de Make Agent Fast de lui accorder un accès. Les deux types d'identifiants appellent les mêmes ressources `/api/v1` et respectent les mêmes portées, droits liés au forfait, isolation entre locataires et limites de débit.

## Clés API [#clés-api]

Un forfait payant actif est requis pour créer et utiliser une clé API publique.

1. Ouvrez **Dashboard → Settings → Developer**.
2. Saisissez un nom qui identifie le service et l'environnement, par exemple `Production lead export`.
3. Sélectionnez les portées minimales dont le service a besoin.
4. Choisissez une expiration : 30 jours, 90 jours, un an ou jamais.
5. Créez la clé et copiez immédiatement la valeur `maf_live_...`.

Make Agent Fast stocke un hachage SHA-256 plutôt qu'un texte en clair récupérable. Le tableau de bord affiche ensuite un préfixe sans risque, les portées, l'expiration, la date de dernière utilisation et l'état de révocation.

```http
Authorization: Bearer maf_live_...
```

Envoyez l'en-tête depuis du code serveur :

```bash
curl --fail-with-body https://makeagent.fast/api/v1/me \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Accept: application/json"
```

L'absence d'identifiants renvoie `401 authentication_required`. Une clé invalide, expirée ou révoquée renvoie `401 invalid_api_key`. Une clé dont le compte n'a plus de forfait payant actif renvoie `403 subscription_required`.

### Faire tourner ou révoquer une clé [#faire-tourner-ou-révoquer-une-clé]

Créez une clé de remplacement avant de révoquer l'ancienne. Déployez la nouvelle clé, effectuez une vraie requête, vérifiez son `x-request-id`, puis cliquez sur **Revoke** sur l'ancienne clé. La révocation est immédiate et irréversible.

Dans les paramètres **Developer**, **Edit** vous permet de modifier le nom et les portées d'une clé active ; la modification s'applique immédiatement à la même clé. Son expiration et son jeton ne peuvent pas être modifiés : créez une clé de remplacement pour obtenir une nouvelle expiration ou un jeton renouvelé.

## Applications OAuth [#applications-oauth]

OAuth est destiné aux logiciels qui se connectent à des comptes appartenant à d'autres utilisateurs de Make Agent Fast. Il utilise le flux Authorization Code avec PKCE (`S256`) et n'émet ni n'exige de secret client. L'identifiant client (client ID) est public ; les codes d'autorisation, les jetons d'accès, les jetons d'actualisation et le vérificateur PKCE sont sensibles.

### 1. Enregistrer l'application [#1-enregistrer-lapplication]

Ouvrez **Dashboard → Settings → Developer → OAuth applications**. Ajoutez :

* Un nom d'application de 2 à 100 caractères.
* Entre 1 et 10 URL de redirection exactes.
* Les portées maximales que votre application peut demander.

Les URL de redirection en production doivent utiliser HTTPS et ne peuvent contenir ni identifiants ni fragments. L'URI complète doit correspondre à une valeur enregistrée lors de l'autorisation et de l'échange du jeton. Les applications nouvellement soumises ont le statut `pending` ; l'autorisation ne fonctionne qu'une fois l'application examinée et marquée `approved`.

Le propriétaire de la plateforme examine les identifiants client en attente
grâce au workflow audité `oauth:review`. Conservez l'identifiant client
affiché après la soumission ; son statut est visible sur la page Developer, et
les applications rejetées incluent la décision de l'examen avant de pouvoir
être soumises à nouveau.

### 2. Générer les valeurs PKCE [#2-générer-les-valeurs-pkce]

Générez un nouveau vérificateur pour chaque tentative d'autorisation et conservez-le dans la même session protégée et de courte durée que `state`.

```ts
import { createHash, randomBytes } from "node:crypto";

const verifier = randomBytes(48).toString("base64url");
const challenge = createHash("sha256").update(verifier).digest("base64url");
const state = randomBytes(24).toString("base64url");
```

Le vérificateur doit contenir de 43 à 128 caractères PKCE compatibles avec les URL. Seul `code_challenge_method=S256` est accepté.

### 3. Rediriger l'utilisateur pour le consentement [#3-rediriger-lutilisateur-pour-le-consentement]

```text
https://makeagent.fast/oauth/authorize
  ?client_id=maf_app_...
  &redirect_uri=https%3A%2F%2Fapp.example.com%2Foauth%2Fcallback
  &response_type=code
  &scope=sites%3Aread%20leads%3Aread
  &state=RANDOM_STATE
  &code_challenge=PKCE_CHALLENGE
  &code_challenge_method=S256
```

L'utilisateur se connecte, examine les portées demandées, puis autorise ou refuse l'accès. En cas de succès, Make Agent Fast redirige vers l'URI enregistrée exacte avec `code` et le `state` d'origine. En cas de refus, il envoie `error=access_denied` ainsi que le `state` d'origine s'il a été fourni.

Rejetez le callback si `state` ne correspond pas exactement à la valeur stockée pour cette session de navigateur.

### 4. Échanger le code d'autorisation [#4-échanger-le-code-dautorisation]

Le code d'autorisation expire au bout de 10 minutes et ne peut être utilisé qu'une seule fois.

```bash
curl --fail-with-body https://makeagent.fast/api/oauth/token \
  -X POST \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "grant_type=authorization_code" \
  --data-urlencode "client_id=maf_app_..." \
  --data-urlencode "code=$AUTHORIZATION_CODE" \
  --data-urlencode "redirect_uri=https://app.example.com/oauth/callback" \
  --data-urlencode "code_verifier=$PKCE_VERIFIER"
```

```json
{
  "access_token": "maf_live_...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "maf_refresh_...",
  "scope": "sites:read leads:read"
}
```

Le jeton d'accès est valable une heure. Le jeton d'actualisation est valable jusqu'à 90 jours, sauf s'il est renouvelé ou révoqué plus tôt.

### 5. Renouveler le jeton d'actualisation [#5-renouveler-le-jeton-dactualisation]

Chaque actualisation réussie révoque à la fois le jeton d'actualisation soumis et son jeton d'accès précédent, puis renvoie une nouvelle paire. Enregistrez la nouvelle paire de manière atomique avant de supprimer l'état de la réponse précédente.

```bash
curl --fail-with-body https://makeagent.fast/api/oauth/token \
  -X POST \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "grant_type=refresh_token" \
  --data-urlencode "client_id=maf_app_..." \
  --data-urlencode "refresh_token=$REFRESH_TOKEN"
```

La réutilisation d'un code d'autorisation ou d'un jeton d'actualisation déjà renouvelé renvoie `invalid_grant`. Le point de terminaison de jeton OAuth renvoie des réponses de style OAuth `{ "error", "error_description" }` plutôt que l'enveloppe d'erreur de l'API publique, et autorise 30 requêtes de jeton par adresse IP d'appelant et par minute.

## N'authentifiez jamais les requêtes de gestion dans du code navigateur [#nauthentifiez-jamais-les-requêtes-de-gestion-dans-du-code-navigateur]

Ne placez jamais de clé API secrète, de jeton d'accès ou de jeton d'actualisation dans des composants client React, du JavaScript statique, du web mobile, Webflow, Framer, Wix ou du Liquid Shopify. Utilisez votre backend authentifié. L'intégration publique pour site web utilise un slug de site non secret et une liste d'origines autorisées, et non des identifiants de l'API de gestion.

Consultez [Credentials and tokens](/fr/docs/api/credentials), [Scopes and errors](/fr/docs/api/scopes-errors) et [API quickstart](/fr/docs/api/quickstart).

---

# Identifiants et jetons

Source: /fr/docs/api/credentials.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;shield&#x22;, title: &#x22;Identifiants serveur&#x22;, description: &#x22;Les clés API et les jetons OAuth autorisent l'accès à l'API publique.&#x22; },
{ icon: &#x22;connectors&#x22;, title: &#x22;Identifiants de canal&#x22;, description: &#x22;Les jetons de bot et les secrets d'application connectent les fournisseurs de messagerie externes.&#x22; },
{ icon: &#x22;voice&#x22;, title: &#x22;Clés de fournisseur&#x22;, description: &#x22;Les identifiants BYOK règlent les fournisseurs d'IA depuis votre propre compte fournisseur.&#x22; }
]"
/>

Make Agent Fast utilise plusieurs types d'identifiants. Ils ne sont pas interchangeables. Avant de copier une valeur, identifiez quel système l'a émise, quel système la reçoit et si elle peut être exposée sans risque dans un navigateur.

## Cartographie des identifiants [#cartographie-des-identifiants]

| Identifiant                                      | Créé dans                                                  | Utilisé par                               | Secret ? | Format ou valeur type                             |
| ------------------------------------------------ | ---------------------------------------------------------- | ----------------------------------------- | -------- | ------------------------------------------------- |
| Slug du site publié                              | Tableau de bord du site                                    | Chargeur d'intégration du site web        | Non      | `my-agent`                                        |
| Clé API Make Agent Fast                          | **Paramètres → Développeur**                               | Votre backend ou votre automatisation     | Oui      | `maf_live_...`                                    |
| ID client OAuth                                  | **Paramètres → Développeur**                               | Application multi-comptes                 | Non      | `maf_app_...`                                     |
| Jeton d'accès OAuth                              | Point de terminaison de jeton OAuth                        | Le backend de votre application           | Oui      | Jeton Bearer, durée de vie d'une heure            |
| Jeton d'actualisation OAuth                      | Point de terminaison de jeton OAuth                        | Votre stockage sécurisé de jetons         | Oui      | `maf_refresh_...`, renouvelé à chaque utilisation |
| Clé API de fournisseur d'IA (facultative, Scale) | OpenRouter (texte) ou Speko (voix)                         | Backend de Make Agent Fast                | Oui      | `sk-or-...` ou `sk_speko_...`                     |
| Jeton de connecteur ou secret d'application      | Telegram, Meta, Discord ou Kakao                           | Service de connecteurs de Make Agent Fast | Oui      | Propre à chaque fournisseur                       |
| Secret de signature de webhook                   | Création du point de terminaison webhook de l'API publique | Votre récepteur de webhook                | Oui      | `whsec_...`                                       |

<Callout title="L'intégration au site web n'utilise pas de clé API">
  Le chargeur d'intégration a besoin d'un slug de site public et d'une origine de site web autorisée. N'ajoutez jamais à la balise script une clé API Make Agent Fast, une clé de fournisseur, un jeton de connecteur ou un secret de webhook.
</Callout>

## Choisir la bonne méthode d'autorisation [#choisir-la-bonne-méthode-dautorisation]

Utilisez une **clé API Make Agent Fast** pour un serveur que vous contrôlez et un seul compte Make Agent Fast. Choisissez uniquement les portées dont ce serveur a besoin.

Utilisez **OAuth Authorization Code avec PKCE** lorsque votre produit connecte des comptes appartenant à d'autres utilisateurs de Make Agent Fast. Les applications OAuth doivent être examinées avant que l'autorisation en production n'aboutisse.

Utilisez une **clé de fournisseur d'IA** uniquement si vous souhaitez que Make Agent Fast appelle ce fournisseur d'IA avec votre compte fournisseur. Une clé de fournisseur n'autorise pas l'accès à l'API publique de Make Agent Fast.

Utilisez les **identifiants de connecteur** uniquement dans le formulaire de connecteur correspondant ou dans la requête d'API de connecteur correspondante. Un jeton de bot Telegram ne peut pas autoriser Discord, Meta ni les requêtes de l'API Make Agent Fast.

## Stocker les secrets en toute sécurité [#stocker-les-secrets-en-toute-sécurité]

En développement local, placez les secrets dans un fichier d'environnement ignoré par Git ou dans l'environnement de votre shell :

```bash
export MAF_API_KEY="maf_live_..."
```

Pour le déploiement, utilisez le gestionnaire de secrets chiffré de votre hébergeur. Ne placez pas de secrets dans :

* Les commits Git, les descriptions de tickets, les captures d'écran, les propriétés d'analytique ou les messages d'assistance.
* Les variables `NEXT_PUBLIC_*`, `VITE_*` ou toute autre variable intégrée au JavaScript du navigateur.
* Webflow, Framer, Wix, le Liquid de Shopify, le HTML de WordPress ou un bundle web mobile.
* Les chaînes de requête. Les URL sont souvent conservées dans l'historique du navigateur, les proxys et les journaux.

Effectuez les appels d'API depuis votre backend authentifié. Le navigateur doit appeler votre backend, et c'est votre backend qui doit joindre le secret.

```ts
const response = await fetch("https://makeagent.fast/api/v1/sites", {
  headers: { Authorization: `Bearer ${process.env.MAF_API_KEY}` },
});
```

## Règles pour les secrets affichés une seule fois [#règles-pour-les-secrets-affichés-une-seule-fois]

Les clés API, les secrets de signature de webhook et les jetons d'actualisation OAuth nouvellement émis doivent être copiés au moment où ils s'affichent. La valeur complète en clair ne peut pas être récupérée par la suite. En cas de perte, créez un remplacement au lieu de demander au support de la révéler.

Les identifiants de fournisseur d'IA et de connecteur sont chiffrés avant d'être stockés et ne sont pas renvoyés par les API de liste. Le tableau de bord peut afficher un libellé, un préfixe, les quatre derniers caractères, un état de validation ou la date de dernière utilisation afin que vous puissiez identifier un identifiant sans l'exposer.

## Liste de contrôle pour le renouvellement [#liste-de-contrôle-pour-le-renouvellement]

1. Créez le remplacement avec les mêmes portées minimales ou les mêmes autorisations de fournisseur.
2. Mettez à jour un déploiement ou un récepteur à la fois.
3. Vérifiez qu'une requête réelle aboutit et notez son `x-request-id`.
4. Révoquez l'ancien identifiant.
5. Vérifiez que les anciennes requêtes échouent avec `401 invalid_api_key` ou l'erreur équivalente du fournisseur.

Pour OAuth, enregistrez le nouveau jeton d'actualisation renvoyé par chaque réponse d'actualisation avant de supprimer le précédent. Pour le renouvellement d'un secret de webhook, faites fonctionner l'ancien et le nouveau point de terminaison en parallèle jusqu'à ce que tous les producteurs et récepteurs utilisent le remplaçant.

## En cas d'exposition d'un secret [#en-cas-dexposition-dun-secret]

Révoquez-le ou renouvelez-le immédiatement. Le supprimer du dernier commit Git ne suffit pas, car il peut subsister dans l'historique, les caches, les journaux ou les forks. Examinez l'activité chez Make Agent Fast et chez le fournisseur émetteur, puis remplacez tout identifiant qui partageait le même emplacement de stockage ou le même environnement de déploiement.

Poursuivez avec [Authentification](/fr/docs/api/authentication), [Portées et erreurs](/fr/docs/api/scopes-errors) ou [Clés de fournisseur d'IA](/fr/docs/account/provider-keys).

---

# Présentation de l'API

Source: /fr/docs/api/overview.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/api/authentication&#x22;, label: &#x22;Authentification&#x22;, icon: &#x22;shield&#x22; },
{ href: &#x22;/fr/docs/api/quickstart&#x22;, label: &#x22;Démarrage rapide&#x22;, icon: &#x22;bolt&#x22; },
{ href: &#x22;/fr/docs/api/reference&#x22;, label: &#x22;Référence&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/api/webhooks&#x22;, label: &#x22;Webhooks&#x22;, icon: &#x22;link&#x22; },
{ href: &#x22;/fr/docs/api/sdks&#x22;, label: &#x22;SDK&#x22;, icon: &#x22;code&#x22; }
]"
/>

L'API publique repose sur du JSON orienté ressources, via HTTPS, sous `/api/v1`. Elle est disponible avec les offres payantes et applique les mêmes droits d'accès aux sites, aux crédits et aux fonctionnalités que le tableau de bord.

## Ce que vous pouvez automatiser [#ce-que-vous-pouvez-automatiser]

* Les sites et leur état de publication
* La configuration des agents, les FAQ, les produits et les connaissances
* Les conversations (y compris les réponses du propriétaire, la mise en pause et la reprise), les leads, les statistiques, les notifications et les diffusions
* La création de leads et le recueil du consentement, les pipelines d'opportunités, les résultats CRM et la reprise après échec de synchronisation
* Les connecteurs, la monétisation, les tickets, l'équipe, l'utilisation et les informations du compte
* Les abonnements à des webhooks signés pour les événements pris en charge

Les actions sensibles passent par des points de terminaison d'action explicites, et non par une modification directe et sans restriction de la base de données. Les secrets des connecteurs sont acceptés en écriture, mais ne sont jamais renvoyés.

Il s'agit d'une **API de gestion et de synchronisation**. Elle permet de créer et de mettre à jour des leads,
de les intégrer à un pipeline d'opportunités, d'importer des résultats CRM gagnés/perdus
avec leur source d'attribution, de relancer les imports de résultats ayant échoué, et de répondre à un visiteur au nom de l'entreprise,
en mettant l'agent en pause puis en le relançant sur cette conversation. L'envoi de messages en tant que visiteur
reste une opération réservée au widget ; les statistiques et l'utilisation restent en lecture seule. Les domaines personnalisés ont été
supprimés, et les routes `/domains` renvoient `409`.

## Démarrer en toute sécurité [#démarrer-en-toute-sécurité]

Créez une clé à portée limitée dans le tableau de bord, appelez le point de terminaison du compte courant, puis développez votre intégration sur un site de test avant de toucher au contenu de production.

```bash
curl https://makeagent.fast/api/v1/me \
  -H "Authorization: Bearer maf_live_YOUR_KEY"
```

Consultez [Authentification](/fr/docs/api/authentication), le [démarrage rapide de l'API](/fr/docs/api/quickstart) et la [référence de l'API](/fr/docs/api/reference).

---

# Démarrage rapide de l'API

Source: /fr/docs/api/quickstart.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;10 minutes&#x22;, icon: &#x22;bolt&#x22; }, { label: &#x22;Serveur uniquement&#x22;, icon: &#x22;shield&#x22; }, { label: &#x22;REST&#x22;, icon: &#x22;code&#x22; }]" />

Ce guide de démarrage rapide permet de vérifier qu'un backend peut s'authentifier et lire les données de votre compte. Vous avez besoin d'un forfait payant actif, d'un terminal avec `curl` et d'un accès à **Tableau de bord → Paramètres → Développeur**.

L'API v1 actuelle permet de gérer et de synchroniser des ressources. Ce n'est pas un
transport de chat personnalisé : vous ne pouvez pas envoyer de messages en tant que visiteur. Les leads peuvent être créés, mis à jour
et acceptés (`leads:write`), et un owner peut répondre à une conversation, la mettre en pause ou la reprendre
(`conversations:write`).

## 1. Créer une clé à privilèges minimaux [#1-créer-une-clé-à-privilèges-minimaux]

Créez une clé nommée `Local API quickstart`, sélectionnez `account:read` et `sites:read`, puis choisissez une durée de validité courte. Copiez immédiatement la clé en clair : elle ne sera plus affichée par la suite.

N'utilisez pas une clé de fournisseur d'IA, telle qu'une clé OpenRouter ou Speko. L'API publique exige une clé Make Agent Fast commençant par `maf_live_`.

## 2. La stocker pour ce terminal [#2-la-stocker-pour-ce-terminal]

```bash
export MAF_API_KEY="maf_live_..."
```

Vérifiez que la variable existe sans afficher le secret :

```bash
test -n "$MAF_API_KEY" && echo "MAF_API_KEY is set"
```

Ne placez pas la clé dans un fichier `.env`, dans des exemples d'historique du shell, dans des fixtures de test ou dans un bundle de navigateur. Pour le code déployé, utilisez le gestionnaire de secrets de votre hébergeur.

## 3. Consulter le compte [#3-consulter-le-compte]

```bash
curl --fail-with-body --include https://makeagent.fast/api/v1/me \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Accept: application/json"
```

Statut attendu : `200 OK`. Le corps de la réponse contient `data.id`, les informations sur le forfait et les droits d'accès, ainsi qu'un résumé du portefeuille. La réponse contient également `x-request-id` ; conservez cette valeur lorsque vous signalez une requête en échec.

```json
{
  "data": {
    "id": "ACCOUNT_ID",
    "email": "owner@example.com",
    "plan": { "id": "pro", "status": "active" },
    "entitlements": { "site_limit": 3, "live_voice": true },
    "wallet": { "balance": 151 }
  }
}
```

Des champs peuvent être ajoutés sans modifier le chemin `/v1`. Ignorez les champs inconnus au lieu de rejeter la réponse.

## 4. Lister les sites [#4-lister-les-sites]

```bash
curl --fail-with-body "https://makeagent.fast/api/v1/sites?limit=20" \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Accept: application/json"
```

Les réponses de type collection utilisent cette enveloppe :

```json
{
  "data": [],
  "has_more": false,
  "next_cursor": null
}
```

Si `has_more` est vrai, envoyez la valeur exacte de `next_cursor` comme paramètre de requête `cursor` de la requête suivante. Ne décodez pas les curseurs et n'en construisez pas.

## 5. Gérer une erreur structurée [#5-gérer-une-erreur-structurée]

Supprimez temporairement l'en-tête Authorization et répétez l'appel à `/me`. La réponse doit être un `401` accompagné d'un code stable :

```json
{
  "error": {
    "code": "authentication_required",
    "message": "Provide an API key in the Authorization bearer header.",
    "request_id": "6c0b2f2e-..."
  }
}
```

Le code de production doit se baser sur `error.code`, et non comparer `message`. Journalisez l'opération, le statut HTTP et l'identifiant de requête, sans journaliser la clé.

## 6. Effectuer une première écriture en toute sécurité [#6-effectuer-une-première-écriture-en-toute-sécurité]

Créez une clé distincte qui dispose également de `sites:write`, `agents:write` et `knowledge:write` ; n'étendez pas la clé de lecture du démarrage rapide. Suivez les [recettes de l'API](/fr/docs/api/recipes) pour créer un site, ajouter des connaissances fiables et le publier en utilisant des clés d'idempotence explicites.

## Échecs courants de la première requête [#échecs-courants-de-la-première-requête]

| Résultat                      | Cause                                                                    | Solution                                                       |
| ----------------------------- | ------------------------------------------------------------------------ | -------------------------------------------------------------- |
| `401 authentication_required` | En-tête manquant ou différent de `Bearer TOKEN`                          | Ajoutez l'en-tête Authorization exact depuis le code serveur   |
| `401 invalid_api_key`         | Faute de frappe, clé expirée, clé révoquée ou mauvais type d'identifiant | Créez et copiez une nouvelle clé API Make Agent Fast           |
| `403 subscription_required`   | Aucun forfait payant actif                                               | Rétablissez l'abonnement du compte                             |
| `403 insufficient_scope`      | La clé n'inclut pas le scope requis pour l'opération                     | Créez une clé de remplacement avec le scope minimal manquant   |
| `403 account_paused`          | L'accès à l'API a été suspendu pour ce compte                            | Reprenez l'accès à l'API ou contactez l'owner du compte        |
| `429 rate_limit_exceeded`     | Quota d'une minute de la clé épuisé                                      | Attendez la valeur de `Retry-After` et réduisez la concurrence |

Poursuivez avec [Scopes et erreurs](/fr/docs/api/scopes-errors), la [référence de l'API](/fr/docs/api/reference) et les [Limites de débit](/fr/docs/api/rate-limits).

---

# Limites de débit

Source: /fr/docs/api/rate-limits.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Par clé&#x22;, icon: &#x22;shield&#x22; }, { label: &#x22;Une minute&#x22;, icon: &#x22;bolt&#x22; }, { label: &#x22;Retry-After&#x22;, icon: &#x22;code&#x22; }]" />

L'API publique applique un compteur de requêtes sur une minute glissante à chaque clé API ou jeton d'accès OAuth. Créer davantage de clés pour contourner une limite n'est pas pris en charge et peut entraîner des restrictions sur vos identifiants ou votre compte.

## Limites par forfait [#limites-par-forfait]

| Forfait actif | Requêtes par clé et par minute |
| ------------- | -----------------------------: |
| Launch        |                            120 |
| Operate       |                            600 |
| Scale         |                          1 800 |

Un identifiant dont le compte n'a aucun forfait payant actif reçoit une erreur `403 subscription_required` avant que toute capacité de débit ne lui soit accordée. Make Agent Fast peut introduire des limites plus basses, propres à certains endpoints, pour les opérations particulièrement coûteuses ; le cas échéant, la référence de l'endpoint les indiquera explicitement.

## Une réponse limitée en débit [#une-réponse-limitée-en-débit]

Lorsque le quota est épuisé, l'API renvoie `429 rate_limit_exceeded` avec :

```http
HTTP/1.1 429 Too Many Requests
Retry-After: 17
X-RateLimit-Limit: 600
X-RateLimit-Remaining: 0
X-Request-Id: 6c0b2f2e-...
Content-Type: application/json
```

`Retry-After` indique le nombre minimal de secondes à attendre. Chaque réponse authentifiée inclut également `X-RateLimit-Limit`, `X-RateLimit-Remaining` et `X-RateLimit-Reset` (un horodatage Unix), ce qui permet aux applications de limiter leur débit avant d'obtenir une erreur `429`.

## Implémenter les nouvelles tentatives [#implémenter-les-nouvelles-tentatives]

Utilisez un backoff exponentiel avec un jitter aléatoire, respectez une valeur de `Retry-After` plus élevée et plafonnez le nombre total de tentatives.

```ts
async function requestWithRetry(url: string, init: RequestInit, attempts = 4) {
  for (let attempt = 0; attempt < attempts; attempt += 1) {
    const response = await fetch(url, init);
    if (response.status !== 429 && response.status < 500) return response;

    if (attempt === attempts - 1) return response;
    const retryAfter = Number(response.headers.get("retry-after") ?? 0) * 1_000;
    const exponential = 500 * 2 ** attempt;
    const jitter = Math.random() * 250;
    await new Promise((resolve) =>
      setTimeout(resolve, Math.max(retryAfter, exponential + jitter)),
    );
  }
  throw new Error("unreachable");
}
```

Pour `POST`, `PATCH` et `DELETE`, conservez la même clé `Idempotency-Key` valide à chaque nouvelle tentative, qu'elle fasse suite à une erreur réseau ou serveur. Une nouvelle clé d'idempotence peut répéter un effet de bord déjà exécuté.

## Réduire le volume de requêtes [#réduire-le-volume-de-requêtes]

* Mettez en cache les lectures de compte, de site et de configuration qui n'exigent pas une fraîcheur en temps réel.
* Demandez jusqu'à `100` enregistrements par page plutôt que de solliciter à répétition de très petites pages.
* Traitez les événements de webhook au lieu d'interroger régulièrement les conversations, les leads ou les diffusions.
* Limitez la concurrence des workers par clé API : une rafale provenant de nombreuses invocations serverless partage le même compteur.
* Utilisez des clés distinctes pour des services distincts afin d'assurer l'isolation et la traçabilité, et non pour multiplier la capacité d'une même charge de travail.

## Tableau des réponses à retenter ou non [#tableau-des-réponses-à-retenter-ou-non]

| Réponse                           | Nouvelle tentative ? | Condition                                                                                                   |
| --------------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------- |
| `429`                             | Oui                  | Attendez la durée indiquée par `Retry-After`, ajoutez du jitter et plafonnez le nombre de tentatives        |
| `500`                             | Parfois              | Lectures sûres ou mutations protégées par la même clé d'idempotence                                         |
| `409` conflit de traitement       | Oui                  | Attendez la durée de son en-tête `Retry-After: 2` et conservez la même clé d'idempotence                    |
| Autre `409`                       | Pas immédiatement    | Lisez l'état actuel de la ressource et résolvez le conflit                                                  |
| `503` `outcome_unknown`           | Non                  | La mutation a peut-être abouti ; vérifiez la ressource avant d'utiliser une nouvelle clé d'idempotence      |
| `400`, `401`, `403`, `404`, `415` | Non                  | Corrigez d'abord les données saisies, les identifiants, les droits d'accès, le chemin ou le type de contenu |

Si une charge de travail soutenue dépasse légitimement le quota de son forfait, réduisez l'interrogation régulière, regroupez les traitements ou contactez le support en fournissant des identifiants de requête représentatifs et le trafic attendu, plutôt que d'ajouter une boucle de nouvelles tentatives sans limite.

---

# Recettes d'API

Source: /fr/docs/api/recipes.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Créer&#x22;, icon: &#x22;site&#x22; }, { label: &#x22;Ancrer&#x22;, icon: &#x22;book&#x22; }, { label: &#x22;Publier&#x22;, icon: &#x22;globe&#x22; }]" />

Ces recettes utilisent l'API REST brute, elles fonctionnent donc avant l'installation d'un SDK public. Définissez `MAF_API_KEY` dans l'environnement du serveur et remplacez les identifiants par ceux renvoyés par les étapes précédentes.

## Recette : créer et publier un agent ancré dans vos sources [#recette--créer-et-publier-un-agent-ancré-dans-vos-sources]

Créez une clé d'API avec les portées `sites:write`, `agents:write` et `knowledge:write`. Ajoutez `sites:read` si l'automatisation doit aussi lister ou vérifier des sites.

### 1. Créer le site [#1-créer-le-site]

```bash
curl --fail-with-body https://makeagent.fast/api/v1/sites \
  -X POST \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: launch-acme-site-2026-01" \
  -d '{
    "title": "Acme support",
    "slug": "acme-support",
    "type": "business",
    "template": "minimal",
    "content": {
      "headline": "Ask Acme support"
    },
    "persona_mode": "assistant",
    "languages": ["en"]
  }'
```

Une réponse réussie renvoie `201 Created`, inclut le site sous `data` et renvoie le chemin canonique de la ressource dans l'en-tête `Location`. Enregistrez `data.id` sous le nom `SITE_ID`.

### 2. Configurer l'agent et la politique d'intégration [#2-configurer-lagent-et-la-politique-dintégration]

```bash
curl --fail-with-body "https://makeagent.fast/api/v1/sites/$SITE_ID/agent" \
  -X PATCH \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: launch-acme-agent-2026-01" \
  -d '{
    "display_name": "Acme guide",
    "persona_mode": "assistant",
    "instructions": "Answer only from confirmed Acme sources. If the answer is missing, say that a teammate will follow up.",
    "languages": ["en"],
    "embed_enabled": true,
    "allowed_origins": ["https://www.acme.example", "https://staging.acme.example"]
  }'
```

Les origines autorisées sont des origines exactes : schéma, nom d'hôte et port facultatif. N'incluez ni chemin ni caractère générique final.

### 3. Ajouter une source de connaissances textuelle [#3-ajouter-une-source-de-connaissances-textuelle]

```bash
curl --fail-with-body "https://makeagent.fast/api/v1/sites/$SITE_ID/knowledge" \
  -X POST \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: launch-acme-returns-2026-01" \
  -d '{
    "name": "Returns policy 2026-01",
    "text": "Customers may request a return within 30 days of delivery. Contact support before sending an item back."
  }'
```

Le texte collé doit comporter entre 5 et 200 000 caractères. Le même endpoint permet aussi d'explorer un site web avec `{ "url", "max_pages", "refresh_hours" }` (`max_pages` jusqu'à 40) ou d'importer `{ "kind": "youtube" | "podcast" | "feed", "url" }` ; ces sources multimédias nécessitent l'offre Operate ou Scale et renvoient `409` sur l'offre Launch. Le téléversement de fichiers reste réservé au tableau de bord.

### 4. Ajouter une FAQ structurée [#4-ajouter-une-faq-structurée]

```bash
curl --fail-with-body "https://makeagent.fast/api/v1/sites/$SITE_ID/faqs" \
  -X POST \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: launch-acme-faq-returns-2026-01" \
  -d '{
    "question": "How long do I have to return an order?",
    "answer": "You may request a return within 30 days of delivery.",
    "approved": true
  }'
```

### 5. Publier [#5-publier]

```bash
curl --fail-with-body "https://makeagent.fast/api/v1/sites/$SITE_ID/publish" \
  -X POST \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: launch-acme-publish-2026-01" \
  -d '{"published": true}'
```

La réponse doit contenir `{"data":{"id":"...","status":"published"}}`. Ouvrez une intégration réelle et posez une question dont la réponse figure dans la source. La publication prouve que l'état de l'agent a changé ; elle ne prouve pas que la qualité de la source ou l'origine de l'intégration sont correctes.

## Recette : paginer les leads en toute sécurité [#recette--paginer-les-leads-en-toute-sécurité]

Utilisez une clé disposant de la portée `leads:read`. Traitez `next_cursor` comme une valeur opaque et encodez-la pour une URL.

```ts
const base = `https://makeagent.fast/api/v1/sites/${siteId}/leads`;
let cursor: string | null = null;

do {
  const url = new URL(base);
  url.searchParams.set("limit", "100");
  if (cursor) url.searchParams.set("cursor", cursor);

  const response = await fetch(url, {
    headers: { Authorization: `Bearer ${process.env.MAF_API_KEY}` },
  });
  if (!response.ok) throw await response.json();

  const page = await response.json();
  for (const lead of page.data) await exportLead(lead);
  cursor = page.next_cursor;
} while (cursor);
```

Ne décodez pas, ne modifiez pas, ne triez pas un curseur et ne le réutilisez pas pour une autre collection.

## Recette : désactiver une intégration pendant un incident [#recette--désactiver-une-intégration-pendant-un-incident]

Utilisez la portée `agents:write` et conservez la même clé d'idempotence lors des nouvelles tentatives dues au réseau :

```bash
curl --fail-with-body "https://makeagent.fast/api/v1/sites/$SITE_ID/agent" \
  -X PATCH \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: incident-2026-07-embed-off" \
  -d '{"embed_enabled": false}'
```

Une fois la réponse reçue avec succès, vérifiez que le lanceur ne s'initialise plus sur un hôte autorisé. Réactivez-le avec une nouvelle clé de résolution d'incident après avoir corrigé le problème d'origine, de contenu ou d'identifiants.

## Liste de contrôle pour la production [#liste-de-contrôle-pour-la-production]

* Utilisez une clé distincte par service et par environnement.
* Conservez les identifiants de ressources et les clés d'idempotence avant d'envoyer une mutation.
* Définissez des délais d'expiration pour la connexion et la réponse.
* Respectez `Retry-After` et plafonnez le nombre de nouvelles tentatives.
* Journalisez le nom de l'opération, le statut HTTP et l'identifiant de requête, sans consigner de secrets ni de données personnelles.
* Testez sur un site hors production avant d'accorder des portées d'écriture en production.

---

# Référence de l'API

Source: /fr/docs/api/reference.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;v1&#x22;, icon: &#x22;code&#x22; }, { label: &#x22;123 opérations&#x22;, icon: &#x22;layers&#x22; }, { label: &#x22;JSON&#x22;, icon: &#x22;book&#x22; }]" />

Le contrat canonique lisible par machine est le [JSON OpenAPI](/api/openapi.json). Cette page est l'index des opérations, rédigé pour les humains, et explique les règles communes à tous les endpoints.

## URL de base et version [#url-de-base-et-version]

```text
https://makeagent.fast/api/v1
```

La version majeure fait partie du chemin. Des champs supplémentaires peuvent apparaître sans changement de version majeure : ignorez donc les champs de réponse inconnus. Toutes les requêtes de gestion utilisent HTTPS ainsi qu'une clé d'API bearer ou un jeton d'accès OAuth.

## En-têtes courants [#en-têtes-courants]

```http
Authorization: Bearer maf_live_...
Accept: application/json
Content-Type: application/json
Idempotency-Key: your-stable-operation-key
```

`Content-Type` est obligatoire pour les corps JSON des requêtes `POST` et `PATCH`, y compris `{}`. `Idempotency-Key` est facultatif, mais vivement recommandé pour chaque `POST`, `PATCH` et `DELETE`.

## Compte et sites [#compte-et-sites]

| Méthode  | Chemin                       | Scope          | Objectif                                                                                                                                                                                                      |
| -------- | ---------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `GET`    | `/me`                        | `account:read` | Lire le résumé du compte, du forfait, des droits et du portefeuille                                                                                                                                           |
| `GET`    | `/sites`                     | `sites:read`   | Lister les sites dont vous êtes propriétaire                                                                                                                                                                  |
| `POST`   | `/sites`                     | `sites:write`  | Créer un site et son agent par défaut                                                                                                                                                                         |
| `GET`    | `/sites/{site_id}`           | `sites:read`   | Récupérer un site dont vous êtes propriétaire                                                                                                                                                                 |
| `PATCH`  | `/sites/{site_id}`           | `sites:write`  | Mettre à jour les champs du site modifiables en toute sécurité                                                                                                                                                |
| `DELETE` | `/sites/{site_id}`           | `sites:write`  | Supprimer le site et les ressources qui en dépendent                                                                                                                                                          |
| `POST`   | `/sites/{site_id}/publish`   | `sites:write`  | Publier ou dépublier avec `{ "published": boolean }`                                                                                                                                                          |
| `GET`    | `/sites/{site_id}/agent`     | `agents:read`  | Lire les paramètres de l'agent                                                                                                                                                                                |
| `PATCH`  | `/sites/{site_id}/agent`     | `agents:write` | Mettre à jour le mode de persona, l'objectif, le nom affiché, les instructions, la voix, les langues, le modèle, l'apparence, l'habillage de l'intégration, le badge, l'état de l'intégration ou les origines |
| `GET`    | `/sites/{site_id}/billing`   | `account:read` | Lire le forfait, la période, le portefeuille, les modules complémentaires et les liens de facturation du tableau de bord                                                                                      |
| `PATCH`  | `/sites/{site_id}/workspace` | `team:write`   | Renommer l'entreprise propriétaire de l'agent                                                                                                                                                                 |
| `PATCH`  | `/sites/{site_id}/retention` | `team:write`   | Définir la durée de conservation des conversations                                                                                                                                                            |

La création d'un site exige `title` et `content.headline`. Les champs facultatifs comprennent `slug`, `type`, `template`, du contenu supplémentaire, `persona_mode`, ainsi qu'une à quatre langues parmi `en`, `ko`, `uz` et `ru`.

`PATCH /agent` soumet `model`, `appearance`, `embed_chrome` et `badge_hidden` aux mêmes contrôles de forfait que le tableau de bord ; `badge_hidden: true` nécessite un forfait éligible ou le module complémentaire de badge.

## Installation et widget de site web [#installation-et-widget-de-site-web]

| Méthode | Chemin                           | Scope          | Objectif                                                                                                     |
| ------- | -------------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------ |
| `GET`   | `/sites/{site_id}/install`       | `agents:read`  | Lire la cible d'installation, l'état de l'intégration, les origines autorisées et les preuves d'installation |
| `PATCH` | `/sites/{site_id}/install`       | `agents:write` | Définir la page sur laquelle le widget doit être installé                                                    |
| `POST`  | `/sites/{site_id}/install/check` | `agents:write` | Vérifier si l'extrait d'intégration est actif sur la page cible                                              |

## Connaissances et FAQ [#connaissances-et-faq]

| Méthode            | Chemin                                                         | Scope                                | Objectif                                                                                                                                        |
| ------------------ | -------------------------------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `GET`              | `/sites/{site_id}/knowledge`                                   | `knowledge:read`                     | Lister les sources de connaissances                                                                                                             |
| `POST`             | `/sites/{site_id}/knowledge`                                   | `knowledge:write`                    | Ingérer du texte collé, explorer un site web ou importer une source YouTube, de podcast ou de flux                                              |
| `PATCH`            | `/sites/{site_id}/knowledge/{source_id}`                       | `knowledge:write`                    | Définir `refresh_hours` ou le `approval_status` du buyer pack                                                                                   |
| `POST`             | `/sites/{site_id}/knowledge/{source_id}/recrawl`               | `knowledge:write`                    | Mettre en file d'attente une nouvelle lecture d'une source récupérée ; renvoie `202`                                                            |
| `DELETE`           | `/sites/{site_id}/knowledge/{source_id}`                       | `knowledge:write`                    | Retirer une source des futures recherches                                                                                                       |
| `GET`              | `/sites/{site_id}/faqs`                                        | `knowledge:read`                     | Lister les FAQ structurées                                                                                                                      |
| `POST`             | `/sites/{site_id}/faqs`                                        | `knowledge:write`                    | Créer `{ "question", "answer", "approved" }`                                                                                                    |
| `POST`             | `/sites/{site_id}/faqs/generate`                               | `knowledge:write`                    | Rédiger des brouillons de FAQ à partir des connaissances de l'agent                                                                             |
| `POST`             | `/sites/{site_id}/faqs/approve-all`                            | `knowledge:write`                    | Approuver et publier toutes les FAQ en brouillon                                                                                                |
| `PATCH`            | `/sites/{site_id}/faqs/{faq_id}`                               | `knowledge:write`                    | Mettre à jour la question, la réponse ou l'état d'approbation                                                                                   |
| `DELETE`           | `/sites/{site_id}/faqs/{faq_id}`                               | `knowledge:write`                    | Supprimer une FAQ                                                                                                                               |
| `GET` / `PATCH`    | `/sites/{site_id}/fact-sheet`                                  | `knowledge:read` / `knowledge:write` | Lire la fiche d'informations de l'entreprise extraite, ou corriger les informations que l'extraction a mal interprétées                         |
| `POST`             | `/sites/{site_id}/fact-sheet/reextract`                        | `knowledge:write`                    | Relire le site web et reconstruire la fiche d'informations                                                                                      |
| `POST`             | `/sites/{site_id}/qa`                                          | `knowledge:write`                    | Publier des paires de questions-réponses sélectionnées                                                                                          |
| `POST`             | `/sites/{site_id}/answers/revise`                              | `knowledge:write`                    | Apprendre à l'agent la réponse qu'il aurait dû donner                                                                                           |
| `GET`              | `/sites/{site_id}/knowledge-connections`                       | `knowledge:read`                     | Lister les connexions de connaissances Notion, Drive et MCP                                                                                     |
| `GET`              | `/sites/{site_id}/knowledge-connections/connect-links`         | `knowledge:read`                     | Obtenir les URL du tableau de bord qui lancent une connexion Notion ou Drive                                                                    |
| `PATCH` / `DELETE` | `/sites/{site_id}/knowledge-connections/{connection_id}`       | `knowledge:write`                    | Définir la fréquence de synchronisation, les éléments sélectionnés ou l'outil d'importation ; ou déconnecter la connexion et purger ses données |
| `GET`              | `/sites/{site_id}/knowledge-connections/{connection_id}/items` | `knowledge:read`                     | Lister les pages, bases de données ou fichiers qu'une connexion peut importer                                                                   |
| `POST`             | `/sites/{site_id}/knowledge-connections/{connection_id}/sync`  | `knowledge:write`                    | Mettre en file d'attente la synchronisation d'une connexion de connaissances                                                                    |

`POST /knowledge` accepte trois corps : `{ "name", "text" }` avec 5 à 200 000 caractères ; `{ "url", "max_pages", "refresh_hours" }` pour explorer un site web (`max_pages` de 1 à 40, `refresh_hours` de 1 à 8 760 ou `null`) ; et `{ "kind": "youtube" | "podcast" | "feed", "url", "refresh_hours" }`. Les sources YouTube, de podcast et de flux nécessitent Operate ou Scale ; avec Launch, elles renvoient `409 conflict`. L'envoi de fichiers reste un workflow du tableau de bord.

## Conversations, leads, analytique et utilisation [#conversations-leads-analytique-et-utilisation]

| Méthode | Chemin                                                    | Scope                 | Objectif                                                                             |
| ------- | --------------------------------------------------------- | --------------------- | ------------------------------------------------------------------------------------ |
| `GET`   | `/sites/{site_id}/conversations`                          | `conversations:read`  | Lister les fils de conversation                                                      |
| `GET`   | `/sites/{site_id}/conversations/{conversation_id}`        | `conversations:read`  | Récupérer un fil et ses messages paginés                                             |
| `POST`  | `/sites/{site_id}/conversations/{conversation_id}/reply`  | `conversations:write` | Répondre à un visiteur au nom de l'entreprise                                        |
| `POST`  | `/sites/{site_id}/conversations/{conversation_id}/pause`  | `conversations:write` | Mettre l'agent en pause sur cette conversation et la prendre en charge               |
| `POST`  | `/sites/{site_id}/conversations/{conversation_id}/resume` | `conversations:write` | Rendre la conversation à l'agent                                                     |
| `GET`   | `/sites/{site_id}/leads`                                  | `leads:read`          | Lister les leads capturés                                                            |
| `POST`  | `/sites/{site_id}/leads`                                  | `leads:write`         | Créer un lead canonique avec un consentement explicite et des préférences de contact |
| `GET`   | `/sites/{site_id}/leads/{lead_id}`                        | `leads:read`          | Récupérer un lead                                                                    |
| `PATCH` | `/sites/{site_id}/leads/{lead_id}`                        | `leads:write`         | Mettre à jour un lead, le qualifier ou modifier sa politique de contact              |
| `POST`  | `/sites/{site_id}/leads/{lead_id}/accept`                 | `leads:write`         | Accepter un lead dans le pipeline d'opportunités                                     |
| `POST`  | `/sites/{site_id}/leads/{lead_id}/followup`               | `leads:write`         | Envoyer le message de relance à un lead                                              |
| `POST`  | `/sites/{site_id}/leads/{lead_id}/followup/draft`         | `leads:write`         | Rédiger à nouveau le message de relance sans l'envoyer                               |
| `GET`   | `/sites/{site_id}/analytics`                              | `analytics:read`      | Lister les événements d'analytique                                                   |
| `GET`   | `/sites/{site_id}/report`                                 | `analytics:read`      | Lire le rapport d'analytique agrégé                                                  |
| `POST`  | `/sites/{site_id}/report/unanswered-faq`                  | `knowledge:write`     | Répondre à une question sans réponse en la transformant en nouvelle FAQ              |
| `GET`   | `/sites/{site_id}/usage`                                  | `usage:read`          | Lister les événements d'utilisation mesurée                                          |

Ces collections d'événements et d'activité acceptent `limit` et `cursor`. Les enregistrements renvoyés peuvent contenir des données personnelles ; stockez-les et exportez-les conformément à vos obligations en matière de confidentialité.

Les réponses du owner sont prises en charge : `reply`, `pause` et `resume` reprennent la main sur un fil web ou sur une discussion Telegram, WhatsApp, Messenger ou Instagram, exactement comme le fait le tableau de bord. L'envoi de messages au nom du visiteur n'est pas une opération de l'API publique.
La mutation des leads est prise en charge ; ne définissez pas `consent_status: granted` sauf si votre système
dispose d'un enregistrement de consentement défendable. Les consentements inconnus sont exclus des diffusions.

## Pipeline d'opportunités et résultats CRM [#pipeline-dopportunités-et-résultats-crm]

| Méthode         | Chemin                                                                                                        | Scope                              | Objectif                                                                                                                                               |
| --------------- | ------------------------------------------------------------------------------------------------------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `GET` / `POST`  | `/sites/{site_id}/pipeline/stages`                                                                            | `pipeline:read` / `pipeline:write` | Lister ou configurer les étapes                                                                                                                        |
| `GET` / `POST`  | `/sites/{site_id}/pipeline/accounts`                                                                          | `pipeline:read` / `pipeline:write` | Lister ou créer des comptes d'entreprise                                                                                                               |
| `GET`           | `/sites/{site_id}/pipeline/accounts/{account_id}`                                                             | `pipeline:read`                    | Récupérer un compte d'entreprise                                                                                                                       |
| `GET` / `POST`  | `/sites/{site_id}/pipeline/opportunities`                                                                     | `pipeline:read` / `pipeline:write` | Lister ou créer des opportunités                                                                                                                       |
| `GET` / `PATCH` | `/sites/{site_id}/pipeline/opportunities/{opportunity_id}`                                                    | `pipeline:read` / `pipeline:write` | Lire l'activité ou mettre à jour l'attribution, la valeur, l'étape, la prochaine action et la réponse humaine                                          |
| `POST`          | `/sites/{site_id}/pipeline/outcomes`                                                                          | `pipeline:write`                   | Importer de manière idempotente un résultat gagné ou perdu provenant d'un CRM                                                                          |
| `GET`           | `/sites/{site_id}/pipeline/sync-records`                                                                      | `pipeline:read`                    | Lister l'état de synchronisation, les tentatives et les erreurs                                                                                        |
| `POST`          | `/sites/{site_id}/pipeline/sync-records/{sync_record_id}/retry`                                               | `pipeline:write`                   | Relancer un résultat en échec à partir de sa charge utile enregistrée                                                                                  |
| `GET` / `PATCH` | `/sites/{site_id}/pipeline-workflow`                                                                          | `pipeline:read` / `pipeline:write` | Lire ou mettre à jour la politique de réponse commerciale                                                                                              |
| `GET` / `POST`  | `/sites/{site_id}/pilots`                                                                                     | `pipeline:read` / `pipeline:write` | Lister ou démarrer des pilotes guidés                                                                                                                  |
| `GET`           | `/sites/{site_id}/pilots/{pilot_id}`                                                                          | `pipeline:read`                    | Lire un pilote, son étape, ses compteurs et sa liste de tâches                                                                                         |
| `POST`          | `/sites/{site_id}/pilots/{pilot_id}/setup`, `/start`, `/stop`, `/review`, `/decision`, `/complete`, `/delete` | `pipeline:write`                   | Faire avancer un pilote à travers la configuration, la mesure, la revue, la décision et la clôture, ou le supprimer avec ses preuves (sept opérations) |
| `POST`          | `/sites/{site_id}/pilots/{pilot_id}/outcomes`, `/bookings`                                                    | `pipeline:write`                   | Enregistrer le résultat d'un lead ou le résultat d'une réservation (deux opérations)                                                                   |
| `POST`          | `/sites/{site_id}/pilots/{pilot_id}/report/approve`, `/report/revoke`                                         | `pipeline:write`                   | Approuver ou révoquer le rapport de pilote partageable (deux opérations)                                                                               |
| `GET` / `POST`  | `/sites/{site_id}/buyer-packs`                                                                                | `pipeline:read` / `pipeline:write` | Lister les buyer packs, ou en créer un à partir de sources approuvées                                                                                  |
| `PATCH`         | `/sites/{site_id}/buyer-packs/{pack_id}`                                                                      | `pipeline:write`                   | Remplacer le titre, le public cible, le résumé, les sources et les sections d'un pack                                                                  |
| `POST`          | `/sites/{site_id}/buyer-packs/{pack_id}/approve`, `/revoke`                                                   | `pipeline:write`                   | Activer ou désactiver le lien de partage du pack (deux opérations)                                                                                     |

Le `provider` du CRM, l'ID externe et la clé d'idempotence fournis sont conservés dans la
piste d'audit. Une nouvelle tentative ne prend en charge qu'un enregistrement en échec et ne transforme jamais une
écriture externe en cours en faux succès.

## Connecteurs [#connecteurs]

| Méthode  | Chemin                                        | Scope              | Objectif                                                                                                                            |
| -------- | --------------------------------------------- | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
| `GET`    | `/sites/{site_id}/connectors`                 | `connectors:read`  | Lister l'état des connecteurs sans les secrets                                                                                      |
| `POST`   | `/sites/{site_id}/connectors`                 | `connectors:write` | Connecter un canal : valider les identifiants en direct, provisionner son webhook et renvoyer la liste de contrôle de configuration |
| `PATCH`  | `/sites/{site_id}/connectors/{connector_id}`  | `connectors:write` | Définir `status` ou `reply_with_voice`                                                                                              |
| `DELETE` | `/sites/{site_id}/connectors/{connector_id}`  | `connectors:write` | Déprovisionner et supprimer un connecteur                                                                                           |
| `POST`   | `/sites/{site_id}/concierge`                  | `connectors:write` | Demander à la plateforme de connecter un canal de messagerie à votre place                                                          |
| `GET`    | `/sites/{site_id}/domains`                    | `domains:read`     | Supprimé — renvoie `409`. Les domaines personnalisés ne sont pas proposés                                                           |
| `POST`   | `/sites/{site_id}/domains`                    | `domains:write`    | Supprimé — renvoie `409`                                                                                                            |
| `PATCH`  | `/sites/{site_id}/domains/{domain_id}`        | `domains:write`    | Supprimé — renvoie `409`                                                                                                            |
| `POST`   | `/sites/{site_id}/domains/{domain_id}/verify` | `domains:write`    | Supprimé — renvoie `409`                                                                                                            |
| `DELETE` | `/sites/{site_id}/domains/{domain_id}`        | `domains:write`    | Supprimé — renvoie `409`                                                                                                            |

La création d'un connecteur utilise un corps discriminé par canal. Les champs d'identifiants diffèrent pour `telegram`, `whatsapp`, `messenger`, `instagram`, `discord` et `kakao` ; consultez le guide du connecteur correspondant avant d'envoyer des secrets.

## Diffusions, notifications et monétisation [#diffusions-notifications-et-monétisation]

| Méthode  | Chemin                                                | Scope                 | Objectif                                                                    |
| -------- | ----------------------------------------------------- | --------------------- | --------------------------------------------------------------------------- |
| `GET`    | `/sites/{site_id}/broadcasts`                         | `broadcasts:read`     | Lister les diffusions                                                       |
| `POST`   | `/sites/{site_id}/broadcasts`                         | `broadcasts:write`    | Créer un brouillon de diffusion Kakao                                       |
| `POST`   | `/sites/{site_id}/broadcasts/{broadcast_id}/send`     | `broadcasts:write`    | Mettre en file d'attente un brouillon existant ; renvoie `202`              |
| `GET`    | `/sites/{site_id}/notifications`                      | `notifications:read`  | Lister les notifications du owner                                           |
| `POST`   | `/sites/{site_id}/notifications/read-all`             | `notifications:write` | Marquer comme lues toutes les notifications du owner pour cet agent         |
| `PATCH`  | `/sites/{site_id}/notifications/{notification_id}`    | `notifications:write` | Marquer comme lue ou non lue avec `{ "read": boolean }`                     |
| `GET`    | `/sites/{site_id}/alerts`                             | `notifications:read`  | Lire l'état du canal d'alertes du owner et son lien vers le tableau de bord |
| `GET`    | `/sites/{site_id}/monetization/products`              | `monetization:read`   | Lister les produits du site                                                 |
| `POST`   | `/sites/{site_id}/monetization/products`              | `monetization:write`  | Créer un produit `access`, `consult`, `tip` ou `digital`                    |
| `PATCH`  | `/sites/{site_id}/monetization/products/{product_id}` | `monetization:write`  | Mettre à jour les champs du produit et son état actif                       |
| `DELETE` | `/sites/{site_id}/monetization/products/{product_id}` | `monetization:write`  | Supprimer un produit                                                        |

La création d'une diffusion n'accepte actuellement que le canal `kakao`. La mise en file d'attente échoue avec `409 conflict` lorsqu'il n'y a aucun destinataire joignable ou que la diffusion n'est plus un brouillon.

## Actions, tickets et équipe [#actions-tickets-et-équipe]

| Méthode            | Chemin                                              | Scope                          | Objectif                                                                                               |
| ------------------ | --------------------------------------------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------ |
| `GET` / `PATCH`    | `/sites/{site_id}/actions`                          | `agents:read` / `agents:write` | Lire ou configurer les procédures, le webhook public, le lien de réservation et les tickets de support |
| `GET`              | `/sites/{site_id}/tickets`                          | `tickets:read`                 | Lister les tickets de support                                                                          |
| `GET`              | `/sites/{site_id}/tickets/{ticket_id}`              | `tickets:read`                 | Lire un ticket et ses messages                                                                         |
| `PATCH`            | `/sites/{site_id}/tickets/{ticket_id}`              | `tickets:write`                | Définir le statut, la priorité et, facultativement, la personne assignée                               |
| `POST`             | `/sites/{site_id}/tickets/{ticket_id}/messages`     | `tickets:write`                | Ajouter une note interne, ou définir `internal: false` pour répondre au customer par e-mail            |
| `GET`              | `/sites/{site_id}/team`                             | `team:read`                    | Lire les membres, les invitations et les événements d'audit autorisés                                  |
| `POST`             | `/sites/{site_id}/team/invitations`                 | `team:write`                   | Créer un lien d'invitation sans envoyer d'e-mail                                                       |
| `DELETE`           | `/sites/{site_id}/team/invitations/{invitation_id}` | `team:write`                   | Révoquer une invitation en attente                                                                     |
| `PATCH` / `DELETE` | `/sites/{site_id}/team/members/{membership_id}`     | `team:write`                   | Modifier le rôle d'un membre qui n'est pas owner, ou retirer ce membre                                 |

## Webhooks pour développeurs et outils de configuration [#webhooks-pour-développeurs-et-outils-de-configuration]

| Méthode  | Chemin                             | Scope                   | Objectif                                                                                                                                                                                                        |
| -------- | ---------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `GET`    | `/webhook-endpoints`               | `webhooks:read`         | Lister l'état des endpoints sans les secrets de signature                                                                                                                                                       |
| `POST`   | `/webhook-endpoints`               | `webhooks:write`        | Enregistrer une URL HTTPS publique et révéler une seule fois son secret de signature                                                                                                                            |
| `DELETE` | `/webhook-endpoints/{endpoint_id}` | `webhooks:write`        | Supprimer un endpoint et arrêter les futures livraisons                                                                                                                                                         |
| `GET`    | `/setup/tools`                     | Tout identifiant valide | Découvrir les outils de configuration pour les intégrations API, MCP et GitHub                                                                                                                                  |
| `POST`   | `/setup/tools/{tool_name}`         | Propre à l'outil        | Exécuter un outil de configuration ; les requêtes de plateforme nécessitent les scopes de leurs endpoints, l'inspection GitHub utilise `integrations:read` et la préparation de PR utilise `integrations:write` |

Les URL de webhook doivent utiliser HTTPS, ne peuvent pas inclure d'identifiants ni de port personnalisé, et doivent se résoudre uniquement vers des adresses IP publiques.

## Pagination [#pagination]

Les collections paginées acceptent `limit` de `1` à `100` ; la valeur par défaut est `50`. Utilisez le `next_cursor` opaque renvoyé uniquement avec la même collection et les mêmes filtres.

```json
{
  "data": [],
  "has_more": false,
  "next_cursor": null
}
```

Certaines petites collections de configuration renvoient la même enveloppe avec `has_more: false` et n'ont pas besoin de curseur.

## Idempotence [#idempotence]

Une clé d'idempotence doit comporter de 8 à 200 caractères parmi les lettres, les chiffres, `.`, `_`, `:` et `-`. Les résultats sont conservés pendant 24 heures et limités au propriétaire de l'identifiant.

* Même clé et mêmes méthode, chemin, requête et corps : renvoie la réponse enregistrée avec `x-idempotent-replayed: true`.
* Même clé avec des données différentes : renvoie `409 conflict`.
* Même clé pendant que la première requête est en cours de traitement : renvoie `409 conflict` et `Retry-After: 2`.

Enregistrez la clé de façon persistante avant d'envoyer la mutation et réutilisez-la uniquement pour les nouvelles tentatives de cette même opération logique.

## Réponses et erreurs [#réponses-et-erreurs]

Les réponses réussies encapsulent leur ressource dans `data`. Les opérations de création renvoient normalement `201` ; les envois de diffusion mis en file d'attente renvoient `202` ; les autres opérations réussies renvoient `200`. Chaque réponse inclut `x-request-id` et utilise `Cache-Control: no-store` pour les données de l'API.

Consultez [Scopes et erreurs](/fr/docs/api/scopes-errors) pour le tableau complet des codes d'erreur et [Recettes d'API](/fr/docs/api/recipes) pour des workflows à copier.

## Clients MCP [#clients-mcp]

Connectez un client MCP Streamable HTTP à `https://makeagent.fast/api/mcp`. Les clients qui prennent en charge la découverte OAuth ouvrent le navigateur pour la connexion et le consentement. Vérifiez l'identité du client, l'entreprise et les scopes demandés avant d'approuver. La première approbation demande les scopes utilisés par les outils (`sites:read`, `sites:write`, `agents:write`, `analytics:read`, `conversations:read`, `conversations:write`, `leads:read`, `leads:write`, `knowledge:write`) ; un identifiant auquel il manque l'un d'eux doit être autorisé à nouveau. Un forfait actif est requis.

Pour les clients qui utilisent des identifiants configurés manuellement, créez une clé d'API limitée à certains scopes dans les [paramètres développeur](/dashboard/settings/developer) et fournissez-la dans un en-tête `Authorization: Bearer ...`. Ne placez jamais d'identifiants dans le contrôle de code source ni dans le code du navigateur. Révoquez les clés d'API ou les autorisations OAuth depuis les paramètres développeur.

Outils de lecture : `list_agents`, `get_agent`, `get_report`, `list_unanswered_questions`, `list_conversations`, `get_conversation`, `list_leads`. Outils d'écriture : `create_agent_from_website`, `create_agent_from_notes`, `test_agent`, `add_knowledge`, `save_answer`, `reply_to_customer`, `update_lead`, `set_website_widget`. Chaque outil d'agent prend un `agent_id` issu de `list_agents`. `test_agent` consomme des credits comme une réponse normale ; `reply_to_customer` envoie un message au customer et met l'agent en pause sur cette conversation ; `set_website_widget` active ou désactive le widget de chat du site web ; les canaux de messagerie se gèrent depuis le tableau de bord. Les clients pour lesquels MCP Apps est activé (par défaut, la connexion Claude authentifiée) disposent aussi de `list_pending_approvals`, `list_action_runs` et `decide_approval`, qui approuve ou refuse une modification confirmée par le customer ; les autres clients ne voient que les 15 outils ci-dessus. Pour les outils de configuration et d'intégration GitHub, utilisez l'assistant de configuration intégré à l'application ou `/api/v1/setup/tools`.

Les révisions de protocole prises en charge sont `2026-07-28`, `2025-11-25` et `2025-06-18`. Le transport renvoie du JSON ; il ne propose ni SSE hérité ni sessions serveur. Les jetons MCP OAuth n'autorisent que `/api/mcp`, et non les requêtes REST directes. Les jetons d'accès OAuth durent une heure ; les identifiants de rafraîchissement sont renouvelés et expirent après 90 jours. Les clés d'API créées manuellement utilisent l'expiration configurée.

---

# Scopes et erreurs

Source: /fr/docs/api/scopes-errors.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;33 scopes&#x22;, icon: &#x22;shield&#x22; }, { label: &#x22;Codes stables&#x22;, icon: &#x22;code&#x22; }, { label: &#x22;ID de requête&#x22;, icon: &#x22;link&#x22; }]" />

Chaque opération de l'API publique exige un scope explicite. Un identifiant valide qui ne dispose pas de ce scope reçoit `403 insufficient_scope` ; il n'est jamais élevé silencieusement vers un accès plus large.

## Référence des scopes [#référence-des-scopes]

| Scope                 | Autorise                                                                                                                                              |
| --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
| `account:read`        | Lire le compte authentifié, le forfait, les droits et le résumé du portefeuille                                                                       |
| `tickets:read`        | Lire les tickets de support et leurs messages                                                                                                         |
| `tickets:write`       | Mettre à jour les tickets, assigner des collègues et ajouter des notes internes ou des réponses aux clients                                           |
| `team:read`           | Lire les membres de l'équipe, les invitations en attente et les événements d'audit autorisés                                                          |
| `team:write`          | Créer ou révoquer des invitations et gérer les rôles des membres de l'équipe autres que le propriétaire                                               |
| `integrations:read`   | Consulter les installations et les dépôts de GitHub App autorisés                                                                                     |
| `integrations:write`  | Préparer des modifications d'intégration et créer des pull requests en brouillon                                                                      |
| `sites:read`          | Lister et récupérer les sites                                                                                                                         |
| `sites:write`         | Créer, mettre à jour, publier, dépublier et supprimer des sites                                                                                       |
| `agents:read`         | Lire les paramètres de l'agent                                                                                                                        |
| `agents:write`        | Mettre à jour le comportement, la langue, la voix et les paramètres d'intégration de l'agent                                                          |
| `knowledge:read`      | Lister les sources de connaissances et les FAQ                                                                                                        |
| `knowledge:write`     | Créer, mettre à jour et supprimer des sources de connaissances et des FAQ                                                                             |
| `conversations:read`  | Lister les conversations et récupérer leurs messages                                                                                                  |
| `conversations:write` | Prendre le relais d'une conversation : répondre à un visiteur au nom de l'entreprise, mettre l'agent en pause sur cette conversation et la lui rendre |
| `leads:read`          | Lister les leads capturés                                                                                                                             |
| `leads:write`         | Créer, mettre à jour, qualifier et intégrer des leads dans le pipeline d'opportunités                                                                 |
| `pipeline:read`       | Lire les étapes, les comptes, les opportunités, les activités, l'attribution et l'état de synchronisation du CRM                                      |
| `pipeline:write`      | Configurer les étapes ; créer ou mettre à jour des opportunités et des comptes ; importer ou relancer des résultats CRM                               |
| `analytics:read`      | Lire les événements d'analytique des sites                                                                                                            |
| `connectors:read`     | Lister l'état des connecteurs sans renvoyer de secrets                                                                                                |
| `connectors:write`    | Créer, mettre à jour, activer, désactiver et supprimer des connecteurs                                                                                |
| `domains:read`        | Supprimé. Conservé uniquement pour la compatibilité ; chaque route `/domains` renvoie `409`, car les domaines personnalisés ne sont pas proposés      |
| `domains:write`       | Supprimé. Conservé uniquement pour la compatibilité ; chaque route `/domains` renvoie `409`                                                           |
| `broadcasts:read`     | Lister les diffusions et l'état de leur envoi                                                                                                         |
| `broadcasts:write`    | Créer des brouillons et mettre en file d'attente l'envoi d'une diffusion                                                                              |
| `notifications:read`  | Lister les notifications du propriétaire                                                                                                              |
| `notifications:write` | Marquer les notifications comme lues ou non lues                                                                                                      |
| `monetization:read`   | Lister les produits de monétisation                                                                                                                   |
| `monetization:write`  | Créer, mettre à jour, activer, désactiver et supprimer des produits                                                                                   |
| `usage:read`          | Lire les événements d'utilisation mesurée                                                                                                             |
| `webhooks:read`       | Lister les endpoints de webhook et l'état des livraisons                                                                                              |
| `webhooks:write`      | Créer et supprimer des endpoints de webhook                                                                                                           |

Utilisez des scopes en lecture pour les tâches de reporting. N'ajoutez un scope en écriture que si l'intégration effectue réellement cette modification. Par exemple, un export de leads nécessite normalement `sites:read` et `leads:read`, et non `sites:write` ou `agents:write`.

## Échecs liés aux scopes [#échecs-liés-aux-scopes]

```json
{
  "error": {
    "code": "insufficient_scope",
    "message": "The API key does not grant the required scope.",
    "details": { "required": ["sites:write"] },
    "request_id": "6c0b2f2e-..."
  }
}
```

Ajoutez le scope manquant à la clé dans **Paramètres → Développeur → Modifier**, ou créez une clé de remplacement et mettez à jour le secret côté serveur. La modification change le nom et les scopes de la clé sur place ; son expiration et son jeton restent identiques. Les clés émises via OAuth ne peuvent pas être modifiées ; reconnectez l'application pour changer les autorisations qui lui ont été accordées.

## Enveloppe d'erreur [#enveloppe-derreur]

Toutes les erreurs de l'API utilisent la même structure de premier niveau :

```ts
type ApiError = {
  error: {
    code: string;
    message: string;
    details?: unknown;
    request_id: string;
  };
};
```

Basez votre logique sur `error.code`, et non sur le `message` en anglais. Les messages peuvent être améliorés sans changement de version. Consignez `error.request_id` et l'en-tête de réponse `x-request-id` avec le nom de l'opération, le statut et le numéro de la tentative, mais ne consignez jamais l'en-tête d'autorisation ni les secrets de la requête.

## Référence des statuts et des codes [#référence-des-statuts-et-des-codes]

| HTTP  | Code stable               | Signification                                                                                                        | Réponse habituelle                                                                                                                           |
| ----- | ------------------------- | -------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `400` | `invalid_request`         | La validation a échoué ou un champ n'est pas pris en charge                                                          | Corrigez les champs indiqués dans `details` ; ne réessayez pas avec les mêmes données                                                        |
| `400` | `invalid_json`            | Le corps n'est pas un objet JSON ou contient du JSON invalide                                                        | Sérialisez un seul objet JSON valide                                                                                                         |
| `401` | `authentication_required` | L'en-tête Bearer est absent                                                                                          | Joignez un identifiant côté serveur                                                                                                          |
| `401` | `invalid_api_key`         | La clé est invalide, expirée ou révoquée, ou son propriétaire n'existe plus                                          | Remplacez la clé ou effectuez-en la rotation                                                                                                 |
| `403` | `subscription_required`   | Le propriétaire n'a pas de forfait payant actif                                                                      | Rétablissez l'abonnement avant de réessayer                                                                                                  |
| `403` | `insufficient_scope`      | L'identifiant ne dispose pas du scope requis pour l'opération                                                        | Créez un identifiant de remplacement au moindre privilège                                                                                    |
| `403` | `account_paused`          | L'accès à l'API est suspendu pour ce compte                                                                          | Reprenez l'accès à l'API ou contactez le propriétaire du compte                                                                              |
| `404` | `not_found`               | L'endpoint ou la ressource du compte est introuvable                                                                 | Vérifiez le chemin et l'ID appartenant au tenant                                                                                             |
| `409` | `conflict`                | L'état actuel de la ressource empêche l'action                                                                       | Lisez l'état actuel avant de réessayer                                                                                                       |
| `413` | `payload_too_large`       | Le corps JSON dépasse la limite de 256 Ko par requête                                                                | Envoyez un corps plus petit ; répartissez les contenus volumineux sur plusieurs requêtes                                                     |
| `415` | `invalid_request`         | Le corps de la requête de modification n'est pas de type `application/json`                                          | Envoyez `Content-Type: application/json`                                                                                                     |
| `429` | `rate_limit_exceeded`     | Le quota d'une minute du forfait pour cette clé est épuisé                                                           | Attendez le délai indiqué par `Retry-After` et appliquez un jitter                                                                           |
| `500` | `internal_error`          | La requête n'a pas pu être traitée                                                                                   | Réessayez une opération sûre ou idempotente et signalez l'ID de requête                                                                      |
| `503` | `outcome_unknown`         | Une modification a peut-être abouti, mais son résultat n'a pas pu être enregistré ; `details.retryable` vaut `false` | Ne réessayez pas. Lisez la ressource pour vérifier si la modification a eu lieu ; la même clé d'idempotence continue de renvoyer ce résultat |

Les ressources extérieures au compte du propriétaire de l'identifiant peuvent renvoyer `404` plutôt que de révéler si l'ID d'un autre tenant existe.

## Détails de validation [#détails-de-validation]

La validation des champs renvoie des chemins que vous pouvez afficher à côté de vos propres champs de formulaire :

```json
{
  "error": {
    "code": "invalid_request",
    "message": "Request validation failed.",
    "details": [
      { "path": "content.headline", "message": "String must contain at least 1 character(s)" }
    ],
    "request_id": "6c0b2f2e-..."
  }
}
```

Les corps des requêtes de modification doivent être des objets JSON. Les tableaux, les corps vides, les données de formulaire et le JSON envoyé avec un type de contenu texte sont rejetés.

## Décisions de nouvelle tentative [#décisions-de-nouvelle-tentative]

* Réessayez une erreur `429` après le nombre de secondes indiqué dans `Retry-After`.
* Ne réessayez une erreur `500` que pour des lectures sûres ou des écritures protégées par la même `Idempotency-Key`.
* Réessayez l'erreur `409` d'idempotence « en cours » après le délai de l'en-tête `Retry-After: 2`.
* Ne réessayez jamais aveuglément une erreur `503 outcome_unknown`. Vérifiez d'abord la ressource ; n'utilisez une nouvelle clé d'idempotence qu'après avoir confirmé que la modification n'a pas eu lieu.
* Ne réessayez pas les erreurs `400`, `401`, `403`, `404`, `413` ni un conflit d'état tant que la cause n'a pas changé.

Consultez [Limites de débit](/fr/docs/api/rate-limits) pour le comportement de backoff et la [Référence de l'API](/fr/docs/api/reference) pour le scope requis par chaque opération.

---

# État des SDK

Source: /fr/docs/api/sdks.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;REST disponible&#x22;, icon: &#x22;globe&#x22; }, { label: &#x22;OpenAPI&#x22;, icon: &#x22;code&#x22; }, { label: &#x22;SDK en préversion&#x22;, icon: &#x22;bolt&#x22; }]" />

L'API REST versionnée est aujourd'hui la seule surface d'intégration publique prise en charge. Le code source des clients JavaScript, Python et des clients pour frameworks existe dans le dépôt du produit, mais les paquets ne sont actuellement publiés ni sur npm ni sur PyPI.

## Disponibilité [#disponibilité]

| Client                         | Statut                                         | Comment l'utiliser                                                                                                    |
| ------------------------------ | ---------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| REST sur HTTPS                 | **Disponible**                                 | Appelez `https://makeagent.fast/api/v1` depuis n'importe quel client HTTP côté serveur                                |
| Document OpenAPI               | **Disponible**                                 | Téléchargez [/api/openapi.json](/api/openapi.json) et examinez-le avant de générer un client                          |
| `@make-agent-fast/sdk`         | **Préversion en code source — absent de npm**  | N'ajoutez pas cet import à un projet de production tant qu'une version publiée sur un registre n'est pas indiquée ici |
| Paquet Python `makeagentfast`  | **Préversion en code source — absent de PyPI** | Utilisez `requests`, `httpx` ou la bibliothèque standard de Python tant qu'une version PyPI n'est pas indiquée ici    |
| Adaptateurs React, Vue, Svelte | **Préversion en code source — absents de npm** | Privilégiez le modèle de chargement par script documenté pour votre framework                                         |
| Composant web                  | **Préversion en code source — absent de npm**  | Privilégiez le chargeur standard `embed.js`                                                                           |

<Callout title="Un dossier de code source n'est pas une version publiée d'un paquet" tone="warning">
  N'exécutez pas `npm install @make-agent-fast/sdk` ni `pip install makeagentfast` sur la seule base d'un exemple d'import. Cette page indiquera l'URL du registre, la version, les recommandations d'intégrité et la commande d'installation dès qu'un paquet public sera publié.
</Callout>

## JavaScript sans SDK [#javascript-sans-sdk]

```ts
const response = await fetch("https://makeagent.fast/api/v1/sites?limit=100", {
  headers: {
    Authorization: `Bearer ${process.env.MAF_API_KEY}`,
    Accept: "application/json",
  },
});

const body = await response.json();
if (!response.ok) {
  console.error(body.error.code, body.error.request_id);
  throw new Error(`Make Agent Fast request failed (${response.status})`);
}

for (const site of body.data) console.log(site.id, site.title);
```

Conservez la clé API côté serveur. Un bundle navigateur React, Vue ou Svelte doit appeler votre propre backend ou installer le chargeur d'intégration public ; il ne doit pas appeler l'API de gestion avec un secret.

## Python sans SDK [#python-sans-sdk]

```python
import json
import os
import urllib.request

request = urllib.request.Request(
    "https://makeagent.fast/api/v1/sites?limit=100",
    headers={
        "Authorization": f"Bearer {os.environ['MAF_API_KEY']}",
        "Accept": "application/json",
    },
)

with urllib.request.urlopen(request, timeout=20) as response:
    payload = json.load(response)

for site in payload["data"]:
    print(site["id"], site["title"])
```

En production, interceptez `urllib.error.HTTPError` et analysez son corps JSON à l'aide de l'[enveloppe d'erreur stable](/fr/docs/api/scopes-errors).

## Clients générés [#clients-générés]

La génération à partir d'OpenAPI n'est utile que si le document contient les opérations et les schémas dont dépend votre application. Figez la spécification téléchargée, générez le code dans un répertoire facile à relire et examinez chaque différence avant toute mise à niveau.

```bash
curl --fail-with-body https://makeagent.fast/api/openapi.json \
  --output make-agent-fast.openapi.json
```

Ne régénérez pas et ne déployez pas automatiquement un client à partir de l'URL en ligne. L'ajout d'un nouveau champ ne devrait pas casser un client, mais le comportement du générateur et les noms des méthodes générées peuvent tout de même changer.

## Ce que doit inclure une version publique d'un SDK [#ce-que-doit-inclure-une-version-publique-dun-sdk]

Avant qu'un client en préversion soit déclaré disponible, il doit proposer :

* Une page publique sur un registre et une version sémantique immuable.
* Des instructions d'installation, de mise à niveau et des environnements d'exécution pris en charge.
* Des modèles typés de requêtes et de réponses générés à partir du contrat d'API complet.
* Des erreurs structurées qui conservent le statut HTTP et l'identifiant de requête.
* Des utilitaires de pagination qui traitent les curseurs comme opaques.
* Une prise en charge explicite des clés d'idempotence pour les mutations.
* Des tests CI par rapport au contrat `/api/v1` actuel et un journal des modifications publié.

Tant que ces conditions ne sont pas remplies, utilisez les exemples REST du [démarrage rapide de l'API](/fr/docs/api/quickstart) et des [recettes d'API](/fr/docs/api/recipes).

---

# Webhooks

Source: /fr/docs/api/webhooks.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;HMAC-SHA256&#x22;, icon: &#x22;shield&#x22; }, { label: &#x22;Au moins une fois&#x22;, icon: &#x22;bolt&#x22; }, { label: &#x22;8 tentatives&#x22;, icon: &#x22;layers&#x22; }]" />

Les webhooks développeur envoient les événements de votre compte à votre serveur, ce qui vous évite d'effectuer des interrogations régulières (polling). La livraison s'effectue au moins une fois : les événements peuvent être dupliqués, retardés ou arriver dans le désordre.

## Enregistrer un point de terminaison [#enregistrer-un-point-de-terminaison]

Créez une clé disposant de la permission `webhooks:write`, puis enregistrez un récepteur HTTPS public ainsi que le plus petit ensemble d'événements dont vous avez besoin.

```bash
curl --fail-with-body https://makeagent.fast/api/v1/webhook-endpoints \
  -X POST \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: webhook-production-v1" \
  -d '{
    "url": "https://api.example.com/webhooks/make-agent-fast",
    "events": ["lead.created", "conversation.started"]
  }'
```

L'URL doit utiliser HTTPS, ne peut contenir ni nom d'utilisateur, ni mot de passe, ni fragment, ni port personnalisé, et ne doit se résoudre que vers des adresses IP publiques. Les redirections ne sont pas suivies lors de la livraison.

La réponse `201` révèle une seule fois un secret de signature `whsec_...`. Enregistrez-le dans le gestionnaire de secrets du récepteur avant de fermer la réponse. La liste des points de terminaison renvoie ensuite l'URL, les événements, le statut, la dernière livraison et la dernière erreur, mais pas le secret.

## Types d'événements [#types-dévénements]

| Événement                      | Émis lorsque                                                                                 |
| ------------------------------ | -------------------------------------------------------------------------------------------- |
| `site.published`               | Un site est publié                                                                           |
| `site.unpublished`             | Un site repasse à l'état de brouillon                                                        |
| `lead.created`                 | L'agent enregistre un nouveau lead                                                           |
| `lead.qualified`               | L'agent qualifie un lead, ou un lead est accepté dans le pipeline commercial                 |
| `booking.requested`            | Un visiteur demande ou réserve un créneau                                                    |
| `handoff.requested`            | L'agent transmet une conversation à une personne                                             |
| `opportunity.created`          | Un lead devient une opportunité du pipeline                                                  |
| `opportunity.updated`          | L'attribution, la valeur, la prochaine action ou d'autres champs d'une opportunité changent  |
| `opportunity.stage_changed`    | Une opportunité passe à une autre étape                                                      |
| `opportunity.won`              | Une opportunité est clôturée comme gagnée                                                    |
| `opportunity.lost`             | Une opportunité est clôturée comme perdue                                                    |
| `conversation.started`         | Un nouveau fil de conversation démarre                                                       |
| `conversation.message.created` | Un message est ajouté à une conversation                                                     |
| `knowledge.ready`              | Une source de connaissances termine son traitement                                           |
| `broadcast.sent`               | Une diffusion termine son flux d'envoi                                                       |
| `domain.activated`             | Obsolète : les domaines personnalisés ne sont pas proposés ; cet événement n'est jamais émis |

## Format de la requête [#format-de-la-requête]

Make Agent Fast envoie une requête `POST` avec `Content-Type: application/json`, `User-Agent: MakeAgentFast-Webhooks/1.0` et les en-têtes suivants :

```http
maf-event-id: evt_...
maf-event-type: lead.created
maf-signature: t=1784210566,v1=HEX_HMAC_SHA256
```

Le corps JSON repose sur une enveloppe stable. Les champs contenus dans `data` dépendent de l'événement et peuvent recevoir des champs supplémentaires.

```json
{
  "id": "evt_2c34...",
  "type": "lead.created",
  "created_at": "2026-07-16T10:02:46.000Z",
  "data": {
    "site_id": "SITE_ID",
    "lead_id": "LEAD_ID"
  }
}
```

Utilisez l'`id` du corps ou `maf-event-id` comme clé de déduplication. N'utilisez ni l'heure de livraison ni un identifiant de base de données généré.

## Vérifier la signature en Node.js [#vérifier-la-signature-en-nodejs]

Lisez les octets bruts exacts avant l'analyse du JSON. La valeur signée est `TIMESTAMP + "." + RAW_BODY`.

```ts
import { createHmac, timingSafeEqual } from "node:crypto";

export function verifyWebhook(rawBody: Buffer, header: string, secret: string) {
  const values = Object.fromEntries(header.split(",").map((part) => part.split("=", 2)));
  const timestamp = values.t;
  const supplied = values.v1;
  if (!timestamp || !supplied || !/^[a-f0-9]{64}$/.test(supplied)) return false;

  const age = Math.abs(Date.now() / 1_000 - Number(timestamp));
  if (!Number.isFinite(age) || age > 300) return false;

  const expected = createHmac("sha256", secret)
    .update(`${timestamp}.`)
    .update(rawBody)
    .digest("hex");
  return timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(supplied, "hex"));
}
```

Rejetez les signatures malformées et les horodatages plus anciens que la fenêtre de rejeu que vous acceptez ; cinq minutes constituent une valeur par défaut raisonnable. Comparez des octets de longueur fixe en temps constant.

## Vérifier la signature en Python [#vérifier-la-signature-en-python]

```python
import hashlib
import hmac
import time

def verify_webhook(raw_body: bytes, header: str, secret: str) -> bool:
    values = dict(part.split("=", 1) for part in header.split(",") if "=" in part)
    timestamp = values.get("t", "")
    supplied = values.get("v1", "")
    try:
        if abs(time.time() - int(timestamp)) > 300:
            return False
    except ValueError:
        return False

    signed = timestamp.encode() + b"." + raw_body
    expected = hmac.new(secret.encode(), signed, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, supplied)
```

N'analysez et ne traitez le JSON qu'une fois la vérification de la signature réussie.

## Accuser réception et traiter [#accuser-réception-et-traiter]

1. Vérifiez la signature et l'horodatage.
2. Insérez l'identifiant de l'événement dans une table dotée d'une contrainte d'unicité.
3. S'il existe déjà, renvoyez `204` sans répéter l'effet de bord.
4. Validez l'événement (commit) ou mettez votre tâche interne en file d'attente.
5. Renvoyez rapidement une réponse `2xx`.

L'expéditeur de Make Agent Fast expire après 10 secondes. Il ne considère comme réussies que les réponses `2xx` et ne suit pas les redirections.

## Comportement des nouvelles tentatives [#comportement-des-nouvelles-tentatives]

Les livraisons échouées sont mises en file d'attente pour huit tentatives au maximum. Le délai d'attente commence autour de deux secondes, double avec une variation aléatoire (jitter) et est plafonné à une heure ; l'heure réelle de livraison peut être plus tardive lorsque les workers sont occupés. Comme les nouvelles tentatives peuvent survivre à la requête d'origine et arriver dans le désordre, ne partez jamais du principe qu'un événement arrive immédiatement avant un autre.

Ne renvoyez une réponse non `2xx` que si vous souhaitez que Make Agent Fast réessaie. Pour une version d'événement définitivement non prise en charge ou une destination supprimée, acceptez et consignez l'événement, ou supprimez le point de terminaison, plutôt que de produire des échecs transitoires sans fin.

## Renouveler un secret de signature [#renouveler-un-secret-de-signature]

Les secrets de signature ne peuvent être ni révélés ni modifiés. Pour les renouveler en toute sécurité :

1. Créez un second point de terminaison pointant vers un chemin de récepteur temporaire ou versionné.
2. Enregistrez le secret nouvellement révélé.
3. Acceptez et dédupliquez les événements provenant des deux points de terminaison.
4. Vérifiez que le nouveau point de terminaison reçoit des livraisons valides.
5. Supprimez l'ancien point de terminaison avec `DELETE /webhook-endpoints/{endpoint_id}`.

Si l'URL du récepteur reste identique, faites en sorte que l'application réceptrice accepte les deux secrets pendant la période de chevauchement et utilisez les identifiants d'événement pour éviter les effets de bord en double.

## Dépannage [#dépannage]

| Symptôme                  | À vérifier                                                                                                                                   |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Aucune livraison          | Statut du point de terminaison, événements sélectionnés, DNS public, certificat HTTPS, et si l'événement s'est réellement produit            |
| Signature non concordante | Accès au corps brut, concaténation exacte `timestamp.body`, secret correct du point de terminaison, et transformations du corps par un proxy |
| Livraisons répétées       | Code de retour, délai d'expiration de 10 secondes, exceptions internes et unicité des identifiants d'événement                               |
| Erreur d'adresse privée   | Les enregistrements DNS ne doivent se résoudre que vers des adresses publiques ; localhost et les plages internes sont rejetés               |
| Échec de redirection      | Enregistrez directement l'URL HTTPS finale ; les redirections ne sont pas suivies                                                            |

N'incluez jamais le secret de signature, la clé bearer ni la charge utile complète d'un visiteur dans un message adressé au support. Indiquez l'identifiant du point de terminaison, l'identifiant de l'événement, l'heure de l'échec et des journaux du récepteur nettoyés de toute donnée sensible.

---

# Affichage

Source: /fr/docs/build/appearance.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Thème&#x22;, icon: &#x22;spark&#x22; }, { label: &#x22;Chat&#x22;, icon: &#x22;chat&#x22; }, { label: &#x22;Appel en direct&#x22;, icon: &#x22;voice&#x22; }]" />

L'apparence du widget stylise ensemble le **chat** et l'**appel en direct** du visiteur : couleurs, thème, angles, ombre, effet verre et polices. Elle ne crée pas de page marketing hébergée. Les nouveaux agents sont mis en ligne sous forme d'intégration sur votre site existant.

Ouvrez la page **Agent** de l'agent, puis choisissez l'onglet **Affichage**. Chaque réglage s'applique aux deux surfaces, et le canevas en direct à côté de l'onglet affiche le véritable widget.

<TutorialVideo episode="ep02" start="108" />

## Les modifications sont appliquées automatiquement [#les-modifications-sont-appliquées-automatiquement]

Il n'y a pas de bouton d'enregistrement. Les champs de texte et les curseurs s'enregistrent après une courte pause ; les interrupteurs, les préréglages et les choix s'enregistrent immédiatement, et une info-bulle **Enregistré** apparaît à côté du réglage. Chaque enregistrement met à jour l'agent et actualise l'intégration (ainsi que toute page hébergée résiduelle), de sorte que les visiteurs voient la modification sans attendre une nouvelle publication. Vérifiez le résultat dans une fenêtre privée, sur une véritable intégration.

Le masquage ou l'affichage du badge sur les offres Operate et Scale utilise la même actualisation en direct.

## Utiliser le site, Clair ou Sombre [#utiliser-le-site-clair-ou-sombre]

**Thème de l'agent** propose trois choix :

| Choix                | Effet                                                                                                                      |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| **Utiliser le site** | Suit le mode clair ou sombre de chaque visiteur (d'abord la page hôte, puis le système d'exploitation). Valeur par défaut. |
| **Clair**            | Fixe le chat et l'appel en direct sur la palette claire.                                                                   |
| **Sombre**           | Fixe le chat et l'appel en direct sur la palette sombre.                                                                   |

**Utiliser le site** correspond à `auto`. Un thème Clair ou Sombre fixe s'applique au chat et à l'appel en direct pour tous les visiteurs. Modifiez les palettes claire et sombre séparément ; le sélecteur de l'aperçu change uniquement la palette que vous modifiez.

Dans une intégration, le chargeur peut toujours transmettre `data-theme="light"` ou `data-theme="dark"` comme remplacement défini par l'hôte. Consultez [Présentation de l'intégration](/fr/docs/embed/overview).

## Couleurs, préréglages et typographie [#couleurs-préréglages-et-typographie]

* **Préréglages** (Net, Doux, Verre, Minimal) : ils définissent ensemble les angles, l'ombre, la bordure et l'effet verre.
* **Couleur principale** : bulles du visiteur, accents de l'appel et actions principales. **Auto (accent du site)** reprend la couleur d'accent de la marque détectée sur votre site, utilisée pour le widget.
* Ajustez finement la couleur secondaire, l'arrière-plan, la surface du panneau, les angles, l'ombre, la bordure, l'effet verre et la police.
* **Identique au site** pour la police s'applique lorsque l'agent est intégré à un site externe ; **Widget par défaut** conserve la police du widget.

Veillez à un contraste suffisant et à des états interactifs bien distincts. Faites un aperçu en largeur de bureau et en largeur réduite, avec des libellés en coréen et en anglais.

## Appel en direct dans l'aperçu de l'affichage [#appel-en-direct-dans-laperçu-de-laffichage]

Le canevas à côté de l'onglet **Affichage** montre le véritable widget : le chat et l'appel en direct apparaissent donc avec la palette claire ou sombre sélectionnée et le même habillage visiteur que dans l'intégration. Parler à l'agent à cet endroit reste un test réalisé par le propriétaire. Consultez [Voix et appels en direct](/fr/docs/build/voice).

## Badge de marque [#badge-de-marque]

La suppression du badge est disponible sur les offres Operate et Scale. Les sites de l'offre Launch conservent le badge de parrainage Make Agent Fast. La modification du réglage du badge (**Afficher le badge « Made with »**) met également à jour l'intégration en direct, sans nouvelle publication.

---

# Réservation avec Cal.com

Source: /fr/docs/build/cal-com.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/change-actions&#x22;, label: &#x22;Confirmations et reçus&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Conversations&#x22;, icon: &#x22;book&#x22; }
]"
/>

## Connecter votre calendrier [#connecter-votre-calendrier]

Ouvrez **Agent → Actions → Cal.com**. Saisissez une clé API Cal.com commençant par `cal_`, l'identifiant numérique positif du type d'événement et un fuseau horaire IANA tel que `Asia/Seoul`. Choisissez **Enregistrer la connexion**. Chaque agent dispose de sa propre connexion. La clé est chiffrée côté serveur ; le tableau de bord n'en affiche que les quatre derniers caractères. Lorsque vous mettez à jour une connexion existante, laissez le champ de la clé vide pour la conserver.

Choisissez **Tester la connexion** pour lire jusqu'à trois prochains créneaux sur les sept jours à venir, à partir des paramètres saisis. Ce test n'enregistre pas la connexion et ne crée aucune réservation. L'absence de créneaux peut simplement signifier que le type d'événement n'a aucune disponibilité sur cette période. Si le test échoue, vérifiez la clé, le type d'événement et le planning dans Cal.com. La suppression de la connexion interrompt les nouvelles réservations Cal.com ; elle n'annule pas les réservations existantes.

Les paiements ne sont pas pris en charge. [Google Calendar](/fr/docs/build/google-calendar) constitue une option distincte, qui n'est pas encore disponible pour tous.

## Des créneaux à la réservation [#des-créneaux-à-la-réservation]

1. L'agent appelle `find_slots` pour obtenir les vraies disponibilités futures. Il présente jusqu'à huit horaires dans le fuseau horaire configuré. La plage par défaut va d'aujourd'hui jusqu'à sept jours plus tard ; l'intervalle maximal est de 14 jours. Lorsqu'un seul horaire est disponible, il est présenté seul.
2. Le client choisit un horaire et fournit son nom, son e-mail et, facultativement, une note. L'agent vérifie à nouveau que l'horaire est libre et qu'il a bien été proposé dans cette conversation. Les propositions de créneaux expirent au bout de 15 minutes.
3. Une carte de confirmation indique la date, l'heure, le fuseau horaire et les informations du participant. Le client doit appuyer sur **Confirmer**. Un message dans le chat ou la simple sélection d'un horaire ne réserve rien. La proposition expire au bout de 15 minutes et ne bloque pas le créneau.
4. Ce n'est qu'après la confirmation que l'adaptateur demande la réservation à Cal.com. Un résultat Cal.com `accepted` devient `done`, avec l'UID de la réservation comme référence. Les statuts `pending` ou `awaiting_host` restent en attente ; un refus ou une annulation devient un échec.

Sur les canaux de messagerie, les propositions de réservation ne sont disponibles que dans les conversations privées. La répétition ne appelle pas Cal.com et ne crée aucune réservation. Sans connexion Cal.com, le flux existant de demande de réservation reste disponible ; il ne prouve pas qu'un créneau a été réservé dans un calendrier. Modifier la clé, le type d'événement ou le fuseau horaire invalide la cible d'exécution d'une proposition : recommencez après toute modification de la connexion.

## Si un créneau est pris ou si le résultat est incertain [#si-un-créneau-est-pris-ou-si-le-résultat-est-incertain]

Un autre client peut prendre un créneau avant que la confirmation ne soit terminée. Si l'horaire n'est plus libre, l'agent indique qu'il n'est pas disponible ; si Cal.com refuse la réservation lors de sa création, le reçu indique un échec. Demandez de nouveaux horaires et confirmez une nouvelle proposition. Le reçu d'échec ne joint pas automatiquement de nouveaux choix.

Un délai d'attente réseau ne prouve ni l'échec ni la réussite. Le reçu affiche un résultat inconnu pendant que le service effectue une nouvelle vérification. Le point de terminaison de création de Cal.com n'a pas de contrat d'idempotency-key documenté ; l'adaptateur enregistre donc l'identifiant d'exécution dans `metadata.maf_run` et recherche cette réservation, tous statuts et toutes pages confondus, avant de retenter la création. Une recherche incomplète n'autorise jamais une nouvelle requête de création. Cela réduit le risque de doublon, mais ne constitue pas une garantie d'exécution unique (exactly-once) offerte par le fournisseur. Avant de faire une nouvelle réservation après l'épuisement des tentatives, vérifiez dans Cal.com.

L'approbation de l'hôte dans Cal.com est distincte de l'approbation du propriétaire pour les actions de modification personnalisées. Une réservation Cal.com en attente n'est pas actualisée automatiquement par cette intégration ; vérifiez son statut final dans Cal.com. Le widget web peut interroger régulièrement le reçu d'exécution enregistré, et les canaux privés pris en charge reçoivent des reçus différés, dans la limite de leurs fenêtres de service. Consultez [la remise des reçus](/fr/docs/build/change-actions#customer-confirmation-and-receipts).

## Versions de l'API et vérifications avant mise en production [#versions-de-lapi-et-vérifications-avant-mise-en-production]

L'adaptateur envoie une authentification Bearer et les valeurs `cal-api-version` suivantes, propres à chaque point de terminaison, vérifiées dans la documentation officielle le **2026-10-13** :

| Opération                       | Version      | Référence                                                                                               |
| ------------------------------- | ------------ | ------------------------------------------------------------------------------------------------------- |
| Lecture des créneaux            | `2024-09-04` | [GET /v2/slots](https://cal.com/docs/api-reference/v2/slots/get-available-time-slots-for-an-event-type) |
| Création d'une réservation      | `2026-02-25` | [POST /v2/bookings](https://cal.com/docs/api-reference/v2/bookings/create-a-booking)                    |
| Rapprochement d'une réservation | `2026-05-01` | [GET /v2/bookings](https://cal.com/docs/api-reference/v2/bookings/get-all-bookings)                     |

Avant de l'utiliser avec des clients, testez une réservation contrôlée, vérifiez l'UID dans Cal.com, essayez un créneau déjà pris et contrôlez les reçus sur chaque canal prévu. Un test de connexion réussi prouve uniquement qu'une lecture de créneaux fonctionne, pas qu'une vraie réservation est possible ni que la configuration est prête pour la production.

---

# Actions de modification

Source: /fr/docs/build/change-actions.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/lookups&#x22;, label: &#x22;Consultations en lecture seule&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/build/cal-com&#x22;, label: &#x22;Réservation Cal.com&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: &#x22;Clients connectés&#x22;, icon: &#x22;shield&#x22; }
]"
/>

<TutorialVideo episode="ep06" start="134" />

## Définir une modification [#définir-une-modification]

Utilisez une action de modification pour mettre à jour un enregistrement dans votre propre système, par exemple pour annuler une commande. Ouvrez **Agent → Actions**, configurez le secret de votre agent dans **Clients connectés**, puis ajoutez une **Action de modification** : un nom unique, une description des cas d'utilisation, un point de terminaison HTTPS public et des entrées de type chaîne déclarées. Un nom tel que `cancel_order` devient l'outil du modèle `change_cancel_order`. Les modifications des actions existantes sont enregistrées automatiquement ; attendez l'indicateur d'enregistrement.

Laissez l'option **Client connecté requis** activée pour les enregistrements privés. Votre point de terminaison doit tout de même vérifier que le client authentifié est autorisé à accéder à l'enregistrement demandé, à partir de son identifiant vérifié. Un nom, un e-mail ou un numéro de commande saisi dans le chat ne constitue pas une preuve d'identité. Si vous désactivez ce paramètre, `customer` peut être nul : n'autorisez alors que les modifications adaptées à des visiteurs anonymes. Les paiements sont en dehors du périmètre de cette fonctionnalité.

## Choisir l'approbation du propriétaire [#choisir-lapprobation-du-propriétaire]

La confirmation du client est requise dans tous les modes :

| Mode                                | Après la confirmation du client                                                                                                                                            |
| ----------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sans approbation (`none`)           | Exécution sans décision distincte du propriétaire.                                                                                                                         |
| Toujours approuver (`always`)       | Attente de la décision du propriétaire.                                                                                                                                    |
| Au-delà d'une limite (`over_limit`) | Attente lorsqu'une entrée numérique déclarée est strictement supérieure à la limite ; l'égalité ne nécessite pas d'approbation. Une entrée numérique invalide est rejetée. |

Consultez les demandes en attente dans **Agent → Actions → Approbations**. Le propriétaire du site peut approuver ou refuser. Si des alertes privées Telegram pour le propriétaire sont associées, l'alerte comporte aussi les boutons **Approuver / Refuser**. Seul le chat privé du propriétaire associé peut les utiliser ; les appuis expirés ou répétés ne peuvent pas déclencher une nouvelle exécution. L'approbation expire 24 heures après la confirmation du client. Le client reçoit le résultat, y compris un refus ou une expiration. Les exécutions récentes affichent le statut, les horodatages, la référence et l'identifiant du client.

## Ce que reçoit votre point de terminaison [#ce-que-reçoit-votre-point-de-terminaison]

Aucune requête n'est envoyée lorsque le modèle propose la modification. Après la confirmation du client et l'éventuelle approbation requise du propriétaire, Make Agent Fast envoie :

```http
POST /agent/cancel-order HTTP/1.1
Content-Type: application/json
x-maf-timestamp: <unix-seconds>
x-maf-signature: v1=<64-lowercase-hex-characters>
x-maf-idempotency-key: c5c1d94b-e88f-4bf6-8023-2dcd1e7ac67b
```

```json
{
  "version": 1,
  "action": "cancel_order",
  "runId": "c5c1d94b-e88f-4bf6-8023-2dcd1e7ac67b",
  "requestId": "c5c1d94b-e88f-4bf6-8023-2dcd1e7ac67b",
  "siteId": "YOUR_SITE_ID",
  "input": { "order_id": "A128" },
  "customer": { "id": "customer_123", "email": "customer@example.com" }
}
```

`action` n'inclut pas le préfixe `change_`. Les deux identifiants et l'en-tête d'idempotence restent identiques lors des nouvelles tentatives. `input` ne contient que des chaînes déclarées et nettoyées des espaces superflus ; `customer` est nul ou correspond à l'objet vérifié comprenant `id` et, en option, `email`/`name`.

Utilisez le [vérificateur de signature des consultations](/fr/docs/build/lookups#verify-the-signature) : HMAC-SHA256 avec le secret de votre agent sur `"maf-webhook-v1:" + timestamp + "." + rawBody`, en hexadécimal minuscule précédé de `v1=`. Vérifiez les octets d'origine, la fraîcheur de l'horodatage, le site et l'action attendus, ainsi que l'appartenance au client avant toute écriture. **Dédoublonnez de façon atomique `x-maf-idempotency-key` avec votre modification et conservez le résultat.** Une requête répétée doit renvoyer le résultat enregistré sans modifier à nouveau l'enregistrement. Le verrouillage de la plateforme ne peut pas remplacer le dédoublonnage dans votre système.

## Renvoyer un résultat [#renvoyer-un-résultat]

Renvoyez un JSON 2xx avec le champ obligatoire `status` (`done`, `pending` ou `failed`) et les champs facultatifs `message`, `reference` et `card` :

```json
{
  "status": "done",
  "message": "Order cancelled.",
  "reference": "A128",
  "card": {
    "kind": "status",
    "title": "Order A128",
    "fields": [{ "label": "Order", "value": "A128" }]
  }
}
```

La carte de statut facultative requiert `title` et `fields` ; `kind: "status"` est facultatif. Elle prend en charge `status: { label, tone }`, `reference`, `asOf` et `link: { label, url }`, comme dans les [consultations](/fr/docs/build/lookups#return-a-response). Les tons possibles sont `neutral`, `success`, `warning` ou `danger` ; les liens doivent être des URL HTTPS sûres. Les champs de schéma inconnus sont rejetés. Gardez des textes courts et simples. Le `status` de niveau supérieur détermine le résultat ; le libellé de la carte ne peut pas transformer un résultat en attente en succès.

Utilisez `done` uniquement lorsque la modification est terminée, `pending` lorsqu'elle est encore en cours de traitement, et `failed` en cas d'échec avéré. Les délais d'attente dépassés, les erreurs réseau, les erreurs 5xx et les réponses invalides sont considérés comme incertains (`unknown`). Le rapprochement réessaie après une minute, puis cinq minutes, avec au maximum trois tentatives d'exécution et la même clé ; la planification des files d'attente peut retarder ces délais. Une erreur HTTP 4xx échoue sans nouvelle tentative. Si l'incertitude persiste après épuisement des tentatives, l'exécution échoue et le propriétaire est averti, mais cela ne prouve pas que votre système n'a effectué aucune modification. Vérifiez avant de lancer une autre exécution. `pending` ne déclenche pas de nouvelle exécution.

## Envoyer un rappel final signé [#envoyer-un-rappel-final-signé]

Lorsqu'une exécution `pending` ou `unknown` est résolue, envoyez une réponse finale par POST à `https://makeagent.fast/api/agent/actions/RUN_ID/callback`. Envoyez le même contrat de réponse avec `status: "done"` ou `"failed"` ; `pending` n'est pas accepté ici.

Contrat de rappel mis à jour le 2026-10-14 : signez `maf-callback-v1:` + runId + `:` + timestamp + `.` + rawBody. Si le corps contient `runId`, il doit correspondre à l'identifiant d'exécution du chemin ; une différence renvoie 400. Les signatures d'une autre exécution ou de l'ancien format non lié renvoient 403.

```js
import { createHmac } from "node:crypto";

const body = JSON.stringify({ status: "done", reference: "A128" });
const timestamp = String(Math.floor(Date.now() / 1000));
const signature = createHmac("sha256", agentSecret)
  .update(`maf-callback-v1:${runId}:${timestamp}.${body}`)
  .digest("hex");
const response = await fetch(
  `https://makeagent.fast/api/agent/actions/${encodeURIComponent(runId)}/callback`,
  {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-maf-timestamp": timestamp,
      "x-maf-signature": `v1=${signature}`,
    },
    body,
  },
);
```

Utilisez le secret de votre agent conservé côté serveur et l'identifiant d'exécution reçu dans la requête d'origine. Le rappel utilise **`maf-callback-v1:`**, et non l'espace de noms de la requête sortante. Le décalage d'horodatage doit rester inférieur à cinq minutes. Les signatures invalides renvoient 403 ; les corps invalides renvoient 400 ; une exécution déjà terminée ou incompatible renvoie 409. Un rappel répété n'écrase pas le résultat final. Effectuez la rotation de ce secret en même temps que votre configuration d'identité et de signature du point de terminaison.

## Confirmation du client et accusés [#confirmation-du-client-et-accusés]

Le client examine les entrées exactes et appuie sur **Confirmer** ou **Annuler** dans la proposition. Une proposition expire après 15 minutes ; une nouvelle proposition pour la même action et la même conversation remplace l'ancienne. La confirmation utilise un jeton lié à cette exécution, à ce site et à ce visiteur. Saisir « oui » ou cliquer sur une carte de confirmation générique n'autorise pas la modification. Les boutons de répétition sont inactifs et n'appellent pas votre point de terminaison.

Sur le web, le widget ouvert interroge régulièrement les accusés non terminaux, d'abord toutes les cinq secondes, puis toutes les 30 secondes, pendant 24 heures au maximum. Un accusé peut indiquer : demandé, en attente du propriétaire, en cours, en attente (pending), vérification d'un résultat inconnu, terminé, échoué, refusé, annulé ou expiré. Seul `done` confirme l'achèvement.

Les propositions sur les canaux fonctionnent **uniquement dans les chats privés**, jamais dans les groupes ou les canaux publics. Les accusés différés utilisent la file d'envoi durable : les messages privés ordinaires de bot Telegram sont pris en charge ; WhatsApp, Messenger, Instagram et Telegram Business exigent un message entrant enregistré dans les dernières 24 heures, vérifié à nouveau au moment de l'envoi. L'envoi différé n'est pas disponible pour les requêtes invité Telegram, Discord et KakaoTalk. Les fenêtres fermées et les connexions désactivées peuvent empêcher la livraison ; l'historique des exécutions enregistre néanmoins le résultat.

## Limites et tests [#limites-et-tests]

| Élément                                                          | Limite                                                                                                       |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| Actions de modification                                          | 5 par agent ; noms uniques parmi les modifications et les consultations                                      |
| Noms                                                             | Action : `^[a-z][a-z0-9_]{2,39}$` ; entrée : `^[a-z][a-z0-9_]{1,31}$` ; noms d'action réservés indisponibles |
| Descriptions                                                     | 300 caractères                                                                                               |
| Entrées                                                          | 3 chaînes déclarées, chacune de 200 caractères maximum                                                       |
| Point de terminaison                                             | HTTPS public, 500 caractères maximum, sans identifiants dans l'URL, sans adresses privées ni redirections    |
| Délai d'exécution / réponse / corps du rappel                    | 8 secondes / 32 Kio / 32 Kio                                                                                 |
| Titre de la carte de statut / libellé du champ / valeur / champs | 80 / 40 / 200 caractères / 8 champs                                                                          |
| Expiration de la proposition / de l'approbation                  | 15 minutes / 24 heures après la confirmation                                                                 |

Utilisez un point de terminaison contrôlé pour vérifier la confirmation, l'annulation, l'approbation, le délai d'attente dépassé, la gestion des clés en double et les rappels finaux. Vérifiez ses enregistrements, et pas seulement le texte de l'accusé. La répétition prouve qu'aucune écriture externe n'a lieu ; ce n'est pas un test d'exécution du point de terminaison. Testez chaque canal privé prévu avant de vous fier aux accusés.

---

# Créer un agent

Source: /fr/docs/build/create-agent.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/persona&#x22;, label: &#x22;Persona&#x22;, icon: &#x22;account&#x22; },
{ href: &#x22;/fr/docs/build/knowledge&#x22;, label: &#x22;Connaissances&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/build/voice&#x22;, label: &#x22;Voix&#x22;, icon: &#x22;voice&#x22; },
{ href: &#x22;/fr/docs/build/appearance&#x22;, label: &#x22;Apparence&#x22;, icon: &#x22;spark&#x22; }
]"
/>

Le premier agent part d'une **URL de site web**. Nous explorons les pages publiques accessibles, rédigeons un brouillon d'agent (y compris le style du widget à partir de ces informations) et le gardons hors de votre site web jusqu'à la dernière étape de l'onboarding. La création par chat est désactivée. Il n'existe aucune fonctionnalité de génération de site ni de création par sections.

<TutorialVideo episode="ep01" start="14" />

## Collez une URL [#collez-une-url]

Sur la page d'accueil, collez l'URL et continuez. L'inscription et la connexion conservent `next=/onboarding/launch?url=…`, vous n'avez donc pas à la coller une seconde fois. `/try` permet aux visiteurs de coller une URL et de discuter avec un brouillon filigrané (texte uniquement, avec limite d'usage) avant de le revendiquer lors de l'inscription.

Si vous avez déjà des sites, une URL collée crée tout de même un **nouveau** brouillon non publié. Si la même URL est déjà en cours de traitement, celle-ci est reprise au lieu d'être dupliquée. Un site de première utilisation déjà terminé n'est pas réutilisé.

Ne collez pas de mots de passe, de données privées de customers ni de jetons de connecteur dans le champ d'URL.

## Patientez sur l'écran de génération [#patientez-sur-lécran-de-génération]

Pendant la création du brouillon, l'écran de génération affiche la progression réelle de l'ingestion, de la composition et de l'examen — et non un faux indicateur de chargement :

| Étape                   | Ce qu'elle fait                                                           |
| ----------------------- | ------------------------------------------------------------------------- |
| **Lecture du site**     | Récupère les pages publiques à partir de l'URL                            |
| **Création de l'agent** | Compose l'agent et le style du widget à partir des informations explorées |
| **Test des réponses**   | Lance un autotest à partir de ces connaissances                           |

L'attente typique est de quelques secondes ; un site plus volumineux peut prendre jusqu'à environ une minute. Si l'exploration donne peu de résultats, le brouillon utilise tout de même ce qui a été trouvé. Vous pouvez ajouter des sources après la relecture.

Le brouillon n'est jamais publié automatiquement. Les nouveaux agents ne disposent pas d'une page marketing hébergée.

## Découvrez l'agent et mettez-le en ligne [#découvrez-lagent-et-mettez-le-en-ligne]

Une fois le brouillon créé, l'onboarding affiche deux écrans supplémentaires :

* **Découvrez votre agent** — le vrai chat à côté de trois vérifications rapides. Posez une question, lisez la réponse, puis acceptez-la ou corrigez-la. Les essais en texte consomment des credits ; les demandes de contact et les actions sont simulées.
* **Placez-le là où sont vos customers** — la dernière étape. Elle active le widget pour le site web que vous avez collé et active l'**Agent link** (une page de chat publique à l'adresse propre de votre agent) afin que vous puissiez le tester sur votre téléphone sous **Tester sur votre téléphone**. Ajoutez le code d'installation à votre site, puis cliquez sur **Vérifier mon site**.

Ensuite, l'agent s'ouvre sur sa page **Agent**, le premier élément de la barre latérale de l'agent : les onglets **Vue d'ensemble**, **Affichage**, **Voix** et **Actions** à côté d'un canevas en direct qui montre le vrai widget dans le coin que vous avez choisi. Posez-lui la question qu'un customer poserait à cet endroit. Dans **Vue d'ensemble**, **Vérification des réponses** → **Lancer une vérification** évalue les réponses par rapport à vos connaissances.

Discuter avec l'agent dans le tableau de bord est un test de l'owner. Cela ne met pas l'agent en ligne et ne compte pas pour l'activation.

Pour placer le widget sur votre site web plus tard, ouvrez **Mettre en ligne** → **Widget de site web** sur la page Agent. Si le widget n'est pas encore activé, choisissez **Activer l'intégration**. Une fois activé, la même fenêtre affiche le code d'installation, l'interrupteur **L'afficher sur mon site web** et **Adresses de sites web autorisées**. Vous pouvez masquer le widget à tout moment avec cet interrupteur ou avec la carte **Sur votre site web** de l'onglet **Vue d'ensemble**.

## Activation [#activation]

Une fois en ligne, ajoutez l'intégration ou connectez un channel. Le site est **activé** par la première conversation d'un visiteur ou par le premier lead capturé. Les échanges de test dans le tableau de bord ne comptent jamais.

## Modifier après le premier brouillon [#modifier-après-le-premier-brouillon]

Il n'y a pas de création par chat. Après la relecture, mettez à jour :

* Les instructions dans l'onglet **Vue d'ensemble** de la page Agent, ainsi que **Voix** et **Affichage** dans leurs onglets voisins.
* Les **Connaissances** sur leur propre page dans la barre latérale de l'agent.
* Les modifications d'**Affichage** sont enregistrées automatiquement et mettent à jour l'intégration en ligne sans nouvelle publication.

## Commencer sans URL de site web [#commencer-sans-url-de-site-web]

Si vous envoyez le formulaire de la page d'accueil vide, **Try** s'ouvre quand même. Les visiteurs anonymes peuvent y coller une URL et discuter avec un brouillon ; revendiquez-le lors de l'inscription pour poursuivre l'onboarding. Une URL collée suit toujours le parcours de l'écran de génération décrit ci-dessus.

---

# FAQ et produits

Source: /fr/docs/build/faqs-products.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;FAQ&#x22;, icon: &#x22;book&#x22; }, { label: &#x22;Produits&#x22;, icon: &#x22;layers&#x22; }, { label: &#x22;Connaissances&#x22;, icon: &#x22;link&#x22; }]" />

## Utiliser les FAQ pour les réponses de référence [#utiliser-les-faq-pour-les-réponses-de-référence]

Créez une FAQ par intention de visiteur. Rédigez la question avec les mots employés par vos customers et veillez à ce que la réponse soit complète, sans dépendre d'une autre FAQ.

## Utiliser les produits pour les informations de catalogue [#utiliser-les-produits-pour-les-informations-de-catalogue]

Les produits conviennent à une offre nommée comportant des champs tels que la description, le prix, la disponibilité ou un lien. Maintenez à jour les informations transactionnelles et évitez de promettre des stocks ou des délais de livraison, sauf si votre source est mise à jour de façon fiable.

## Éviter les doublons [#éviter-les-doublons]

Ne gérez pas le même prix dans une note, une FAQ, une section de page et une fiche produit. Choisissez une seule source de référence et renvoyez-y depuis les autres emplacements.

## Vérifier le comportement côté customer [#vérifier-le-comportement-côté-customer]

Après une modification, posez à l'agent la question de la FAQ avec plusieurs formulations et vérifiez que le lien et le prix du produit sont corrects.

---

# Relances et rappels

Source: /fr/docs/build/follow-ups.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/page-actions&#x22;, label: &#x22;Actions de page&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/build/lookups&#x22;, label: &#x22;Recherches&#x22;, icon: &#x22;book&#x22; }
]"
/>

## Proposer de l'aide au bon moment [#proposer-de-laide-au-bon-moment]

Ouvrez **Agent → Actions → Relances**. Ajoutez jusqu'à cinq règles pour une vue de page, un visiteur inactif, une intention de départ, une erreur de formulaire ou un événement personnalisé. Choisissez un motif de chemin, un délai facultatif, un message de 200 caractères maximum et jusqu'à trois réponses rapides. Les paramètres s'enregistrent automatiquement. L'aperçu affiche le message sans contacter de client ni ajouter de données d'expérimentation.

Utilisez `/pricing` pour un seul chemin, `/products/*` pour un segment ou `/products/**` pour des chemins imbriqués. Les paramètres de requête et les fragments sont exclus. Le délai d'inactivité par défaut est de 30 secondes et le délai de réactivation par défaut est de sept jours. Un déclencheur n'interrompt pas une prise en charge par un humain ni une conversation active en cours, ne se répète pas au sein d'une même session et ne réapparaît pas après avoir été fermé durant cette session.

L'intégration (embed) signale les vues de page, l'inactivité et l'intention de départ. Votre développeur peut signaler des événements personnalisés avec `MakeAgentFast.track` ; consultez [Actions de page](/fr/docs/build/page-actions). Le signalement automatique des erreurs de formulaire est désactivé, sauf si l'intégration utilise `data-auto-form-error="true"` ou `MakeAgentFastSettings.autoFormError = true`. Il transmet l'identifiant du formulaire, jamais les valeurs des champs.

## Lire les résultats du groupe de contrôle [#lire-les-résultats-du-groupe-de-contrôle]

Par défaut, 10 % des visiteurs éligibles sont affectés à un groupe de contrôle stable et ne voient aucun message. L'affectation est liée au visiteur et à la règle ; les visites répétées ne gonflent donc pas l'échantillon. Le tableau de bord compare les taux de conversion des visiteurs éligibles entre le groupe qui reçoit le message et le groupe de contrôle, puis affiche l'écart absolu en points de pourcentage.

Une conversion correspond à un lead enregistré, une réservation, une action terminée ou une recherche réussie dans les 24 heures suivant une exposition éligible. L'ouverture ou la réponse sont affichées séparément. Les événements signalés par le navigateur ne peuvent pas déclarer de conversions. En dessous de 50 visiteurs par groupe, le tableau de bord indique qu'il n'y a pas assez de données ; à partir de ce seuil, il affiche un intervalle simple à 95 %. De faibles écarts ne prouvent pas que le message a généré davantage de ventes.

## Prévenir un client lorsque quelque chose change [#prévenir-un-client-lorsque-quelque-chose-change]

Les clients peuvent demander « Prévenez-moi quand un créneau se libère » ou « Informez-moi quand le statut de ma commande change ». Une surveillance suit les disponibilités d'un calendrier connecté ou un champ/statut dans une [recherche](/fr/docs/build/lookups) configurée. Les surveillances de recherche nécessitent un client connecté et vérifié. Elles ne surveillent pas des pages arbitraires et ne planifient pas de rappels récurrents.

L'agent propose une surveillance en indiquant sa destination et sa date de fin. Le client doit appuyer sur le bouton de confirmation dans un délai de 15 minutes. Les visiteurs du site web et des appels en direct saisissent également une adresse e-mail et cochent à l'écran la case de consentement à l'e-mail ; un « oui » saisi ou prononcé ne suffit pas. L'e-mail contient un avis générique et un lien de retour à durée de vie limitée. Ce lien ne connecte pas le destinataire et ne donne pas accès aux dossiers clients.

Chaque visiteur peut avoir trois surveillances actives ou en attente, avec un maximum de 50 par agent et une durée maximale de 14 jours. Les vérifications commencent après 15 minutes, puis s'espacent à une heure et à six heures. Chaque surveillance envoie une seule tentative de notification, puis s'arrête. Annulez-la via les commandes de la surveillance ou la liste Relances du propriétaire. Modifier la configuration de la recherche ou du calendrier sous-jacent peut arrêter une surveillance. Un envoi dont le résultat est incertain n'est pas renvoyé automatiquement.

## Relancer dans les chats et vous solliciter en cas de blocage [#relancer-dans-les-chats-et-vous-solliciter-en-cas-de-blocage]

Ouvrez **Agent → Actions → Relances → Relances de chat**. Ces deux interrupteurs s'appliquent aux chats Telegram, WhatsApp, Messenger et Instagram.

**Relancer lorsqu'un client ne répond plus** est activé par défaut pour les agents commerciaux et désactivé pour les autres types d'agents. Lorsqu'un client cesse de répondre après une réponse, l'agent relit le chat puis envoie un court message, attend un peu plus longtemps ou laisse le client tranquille. Un agent commercial oriente vers l'achat, un agent de service vérifie que le problème est résolu et un agent de réservation propose un créneau. Il s'appuie uniquement sur vos connaissances approuvées et sur la conversation, et s'arrête lorsque le client répond, refuse ou demande à ne pas être contacté. Les canaux Meta n'acceptent les messages automatisés que dans les 24 heures suivant le dernier message du client ; la relance y arrive donc dans la journée, tandis qu'un chat avec un bot Telegram peut recevoir jusqu'à deux relances sur quelques jours. Chaque relance est facturée comme une réponse.

**Me demander quand l'agent ne peut pas répondre** est activé par défaut. Au lieu de demander une adresse e-mail, l'agent indique au client qu'il vérifie auprès de l'équipe et vous alerte avec un lien vers la conversation. Répondez-y, ou enregistrez la réponse dans les connaissances, et l'agent l'envoie au client dans sa langue. Instagram et Messenger acceptent votre réponse pendant 24 heures après le dernier message du client, ou jusqu'à 7 jours une fois que votre application Meta dispose de l'autorisation Human Agent.

## Livraison et disponibilité [#livraison-et-disponibilité]

| Destination                | Limite actuelle                                                                                                                     |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| Site web / appel en direct | E-mail avec consentement explicite ; pas de notification push en arrière-plan via le widget                                         |
| Telegram                   | Chat privé existant avec le bot ; un chat Business privé nécessite également une fenêtre de 24 heures ouverte                       |
| WhatsApp                   | Message libre dans les 24 heures suivant un message entrant du client ; en dehors, un modèle utilitaire approuvé est requis         |
| Messenger / Instagram      | Uniquement dans les 24 heures suivant un message entrant du client                                                                  |
| Discord / KakaoTalk        | Transport de surveillance indisponible ; la politique de Kakao exige en outre un modèle AlimTalk et exclut la plage 20:50–08:00 KST |

Les restrictions des canaux sont vérifiées de nouveau au moment de l'envoi. Une surveillance consentie ne les contourne pas et ne garantit pas la livraison d'un message.

---

# Google Calendar

Source: /fr/docs/build/google-calendar.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/cal-com&#x22;, label: &#x22;Cal.com&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/build/follow-ups&#x22;, label: &#x22;Alertes de disponibilité&#x22;, icon: &#x22;book&#x22; }
]"
/>

## Disponibilité de la fonctionnalité [#disponibilité-de-la-fonctionnalité]

**Google Calendar n'est pas encore disponible pour tous.** Tant qu'il n'est pas activé, **Agent → Actions → Google Calendar** affiche « bientôt disponible » et la connexion est impossible ; aucun paramètre de l'agent ne permet de l'activer. [Cal.com](/fr/docs/build/cal-com) reste une option distincte.

## Connecter un agenda [#connecter-un-agenda]

Lorsque l'intégration est activée, ouvrez le panneau Google Calendar et choisissez **Connecter**. Connectez-vous à Google et vérifiez les autorisations demandées pour les événements de l'agenda et les disponibilités (libre/occupé). Cette connexion est distincte de la connexion à Make Agent Fast. Le serveur stocke le jeton d'actualisation de manière chiffrée ; ni le tableau de bord ni l'agent ne le reçoivent.

Les scopes demandés sont `calendar.events`, `calendar.freebusy`, ainsi que les scopes non sensibles `openid` et `email`. Le callback exige une adresse e-mail vérifiée et la stocke chiffrée afin de faire correspondre `primary` au même ID d'agenda que son écriture explicite par adresse e-mail. Aucun scope de profil n'est demandé. Les connexions plus anciennes, sans adresse e-mail vérifiée, doivent être déconnectées puis reconnectées avant toute réservation.

Un agent utilise un seul fournisseur d'agenda à la fois. Déconnectez le fournisseur existant avant d'en changer. Choisissez l'ID de l'agenda (`primary` pour l'agenda principal du compte connecté) et son fuseau horaire IANA, par exemple `Asia/Seoul`. Un agenda partagé doit être accessible avec les autorisations du compte connecté. La déconnexion révoque l'accès accordé à Google et supprime la connexion ; elle n'annule pas les événements existants.

## Définir les horaires de travail [#définir-les-horaires-de-travail]

Les nouvelles connexions n'ont aucun horaire de travail : aucun créneau n'est proposé tant que vous n'en avez pas ajouté. Ajoutez des plages d'ouverture et de fermeture pour chaque jour de travail. Un jour vide est considéré comme fermé ; plusieurs plages sans chevauchement permettent de prévoir une pause déjeuner. Les horaires sont interprétés dans le fuseau horaire sélectionné. Les paramètres sont enregistrés automatiquement.

| Paramètre                           | Plage acceptée                                      |
| ----------------------------------- | --------------------------------------------------- |
| Durée du créneau                    | 5 à 240 minutes                                     |
| Marge autour des événements occupés | 0 à 120 minutes                                     |
| Préavis minimum                     | 0 à 43 200 minutes                                  |
| Horizon de réservation              | 1 à 90 jours                                        |
| Plages de travail                   | Jusqu'à 28 plages sans chevauchement sur la semaine |

La disponibilité correspond aux horaires de travail, moins les plages occupées de l'agenda sélectionné, la marge, le préavis minimum et l'horizon. Définissez les horaires dans le fuseau horaire prévu pour l'agenda et vérifiez les changements d'heure été/hiver le cas échéant. L'absence de créneaux peut signifier des horaires de fermeture ou des plages occupées, plutôt qu'une erreur de connexion.

## De la disponibilité à la réservation [#de-la-disponibilité-à-la-réservation]

L'agent utilise le même flux `find_slots` et `book_slot` que Cal.com : il propose jusqu'à huit créneaux disponibles, recueille le nom et l'adresse e-mail ainsi qu'une note facultative, revérifie le créneau choisi, puis affiche une carte de confirmation. Les propositions et les offres expirent au bout de 15 minutes ; aucune des deux ne bloque le créneau. Seul l'appui du client sur le bouton autorise la réservation. Un « oui » prononcé pendant un appel en direct ne peut pas la déclencher.

Après confirmation, Google reçoit un événement dont l'ID déterministe est lié à l'exécution de l'action, et envoie les invitations aux participants. Un événement confirmé et validé produit un reçu finalisé ; les événements provisoires restent en attente. Si un créneau est déjà pris, demandez de nouveaux horaires et faites confirmer à nouveau. En cas de résultat réseau incertain, la vérification s'effectue avec le même ID d'événement ; ne considérez pas un délai d'attente dépassé comme une réussite et ne créez pas aveuglément une autre réservation. Toute modification de la configuration invalide les offres et propositions précédentes.

Pour être averti lorsqu'un créneau se libère, utilisez une [surveillance](/fr/docs/build/follow-ups) avec consentement. Avant toute utilisation par des clients, vérifiez une vraie réservation et son invitation dans Google, testez un créneau déjà pris, puis contrôlez la déconnexion et la reconnexion ainsi que le canal de messagerie prévu.

---

# Sources de connaissances

Source: /fr/docs/build/knowledge.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;message&#x22;, title: &#x22;Texte collé&#x22;, description: &#x22;Faits et politiques rédigés par le propriétaire, jusqu'à 200 000 caractères.&#x22; },
{ icon: &#x22;link&#x22;, title: &#x22;URL et flux&#x22;, description: &#x22;Récupérez des pages publiques ou du contenu de site mis à jour régulièrement.&#x22; },
{ icon: &#x22;book&#x22;, title: &#x22;Fichiers&#x22;, description: &#x22;Extrayez le texte des fichiers PDF, Word, Excel, PowerPoint, HWP, OpenDocument, RTF et texte.&#x22; },
{ icon: &#x22;voice&#x22;, title: &#x22;Médias&#x22;, description: &#x22;Utilisez les sous-titres YouTube disponibles ou transcrivez l'audio de podcast pris en charge.&#x22; }
]"
/>

Les connaissances fournissent à l'agent du matériel source exploitable par recherche. Lorsque vous ajoutez une source, le texte brut est extrait, découpé en passages, converti en embeddings, puis associé au site actuel. Au moment de répondre, l'agent récupère les passages pertinents au lieu de recevoir toutes les sources dans chaque prompt.

<TutorialVideo episode="ep01" start="168" />

## Choisir le bon type de source [#choisir-le-bon-type-de-source]

| Source                  | Idéal pour                                                                                                                                                                                           | Comportement important                                                                                                                                                            |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Coller du texte**     | Politiques, coordonnées, courtes notes internes                                                                                                                                                      | 5 à 200 000 caractères ; pas d'actualisation automatique                                                                                                                          |
| **Depuis une URL**      | Pages publiques maintenues ailleurs                                                                                                                                                                  | Une seule page par défaut ; possibilité d'explorer 5, 10, 20 ou 40 pages du même site                                                                                             |
| **Importer un fichier** | PDF, Word (`.docx`, `.doc`), Excel (`.xlsx`, `.xls`), PowerPoint (`.pptx`), Hancom `.hwp` et `.hwpx`, OpenDocument (`.odt`, `.ods`, `.odp`), `.rtf`, `.txt`, `.md`, `.csv`, `.tsv`, `.json`, `.html` | 20 Mo maximum ; les fichiers protégés par mot de passe et ceux contenant des macros sont refusés ; les PDF scannés composés uniquement d'images n'ont pas de texte sélectionnable |
| **YouTube**             | Vidéos publiques au contenu parlé utile                                                                                                                                                              | Offres Operate ou Scale. Essaie d'abord les sous-titres, puis la transcription disponible ; au mieux                                                                              |
| **Podcast**             | L'URL audio publique d'un épisode ou un flux pris en charge                                                                                                                                          | Offres Operate ou Scale. Nécessite un audio accessible et un fournisseur de transcription disponible                                                                              |
| **Blog / RSS**          | Mises à jour publiques d'un blog ou d'un podcast en RSS/Atom                                                                                                                                         | Offres Operate ou Scale. Extrait en texte les éléments de flux disponibles ; au mieux                                                                                             |

Utilisez **FAQ et produits** pour des champs de questions/réponses ou de catalogue prévisibles, plutôt que de les noyer dans un long document. Consultez [FAQ et produits](/fr/docs/build/faqs-products).

## Ajouter une source [#ajouter-une-source]

1. Ouvrez la page **Connaissances** de l'agent depuis la barre latérale de l'agent, puis sélectionnez **Ajouter une source**.
2. Sélectionnez **Coller du texte**, **Depuis une URL** ou **Importer un fichier**. **YouTube**, **Podcast** et **Blog / RSS** se trouvent sous **Autres types de sources** et nécessitent l'offre Operate ou Scale ; avec Launch, un cadenas s'affiche.
3. Saisissez le contenu ou choisissez un fichier.
4. Pour **Depuis une URL**, choisissez **Pages à explorer** (1, 5, 10, 20 ou 40). Pour les sources récupérées, vous pouvez définir **Actualisation automatique** sur **Quotidienne**, **Hebdomadaire** ou **Jamais**.
5. Sélectionnez **Ajouter aux connaissances** et attendez le résultat indiquant le nombre de segments indexés.
6. Posez une question dont la réponse figure uniquement dans la nouvelle source.

L'ingestion de connaissances consomme des crédits, car les passages de la source sont convertis en embeddings. Elle est rejetée si l'espace de travail n'a pas d'accès actif ou de solde de crédits utilisable.

## Explorer des pages publiques en toute sécurité [#explorer-des-pages-publiques-en-toute-sécurité]

Le robot d'exploration accepte le contenu public en HTTP/HTTPS et bloque les destinations non sécurisées situées sur des réseaux privés. Commencez par une seule page canonique. N'augmentez le nombre de pages que si les pages liées font partie du même ensemble d'informations utiles : une exploration plus large peut ajouter de la navigation, des mentions légales génériques, du texte dupliqué ou des archives obsolètes qui dégradent la recherche.

Le nombre sélectionné est un maximum, pas une garantie. Le comportement vis-à-vis des fichiers robots, l'authentification, le rendu uniquement côté client, les redirections, le type de contenu, la taille de la réponse et la structure des liens peuvent réduire le nombre de pages récupérées. La réponse d'une page est limitée à 5 Mo et doit contenir suffisamment de texte extractible.

Pour les informations importantes situées derrière une connexion, collez un résumé approuvé ou importez un export nettoyé plutôt que d'essayer d'explorer une page authentifiée.

## Utiliser des fichiers et des médias [#utiliser-des-fichiers-et-des-médias]

Les fichiers importés doivent contenir du texte extractible. Aucune reconnaissance optique de caractères (OCR) n'est effectuée sur un PDF scanné composé uniquement d'images ; convertissez-le en texte recherchable avant l'import. Les feuilles de calcul sont lues feuille par feuille, et les lignes de tableau conservent leurs cellules ensemble (`Coffee | 3000`) ; les autres mises en page sont aplaties dans l'ordre de lecture, donc gardez des tableaux simples. Supprimez le mot de passe d'un document avant de l'importer, et enregistrez d'abord les fichiers Office avec macros (`.docm`, `.xlsm`, `.pptm`) en fichiers ordinaires `.docx`, `.xlsx` ou `.pptx`. Un fichier dont le contenu ne correspond pas à son extension est refusé.

L'ingestion YouTube privilégie une piste de sous-titres disponible. Si les sous-titres ne sont pas disponibles, la transcription dépend du fournisseur et du réseau. L'audio d'un podcast doit être accessible publiquement. Les résultats d'un flux dépendent de la quantité de texte d'article ou d'épisode que le flux expose. Après toute importation de média, vérifiez le titre de la source et le nombre de segments, puis testez un fait précis au lieu de supposer que l'enregistrement complet a été capturé.

## Planifier l'actualisation et le remplacement [#planifier-lactualisation-et-le-remplacement]

Les planifications quotidienne et hebdomadaire sont disponibles pour les sources URL, YouTube, podcast et flux. Le système récupère à nouveau l'origine enregistrée de la source et remplace ses passages exploitables lorsqu'une exploration planifiée réussit. La liste des sources indique la fréquence d'actualisation et la date de dernière actualisation.

Les sources collées et importées sont des instantanés. Pour en corriger ou en remplacer une, supprimez-la et ajoutez le contenu mis à jour. La suppression d'une source retire ses passages des recherches futures ; elle ne modifie pas les messages passés qui ont déjà cité ou résumé l'ancienne version.

Désignez une seule source de référence claire pour les tarifs, les politiques et les horaires. Si deux sources actives se contredisent, la recherche peut faire remonter l'une ou l'autre affirmation. Supprimez les versions obsolètes plutôt que d'ajouter des copies « nouvelles » à côté.

## Rédiger un contenu que l'agent peut retrouver [#rédiger-un-contenu-que-lagent-peut-retrouver]

* Indiquez le sujet dans chaque section : « Politique d'annulation du forfait Pro » est plus facile à retrouver que « Plus de détails ».
* Placez la réponse en langage clair près du titre concerné.
* Précisez les unités, la devise, le fuseau horaire, la date d'entrée en vigueur et les exceptions lorsqu'elles comptent.
* Utilisez des URL canoniques stables et des noms de fichiers descriptifs.
* Séparez les informations publiques des instructions internes ou des données privées.
* Gardez le comportement du persona dans [Persona et instructions](/fr/docs/build/persona), et non dans le matériel source factuel.

## Tester les réponses fondées sur les sources [#tester-les-réponses-fondées-sur-les-sources]

Créez un petit jeu de tests d'acceptation avant la publication :

1. Une question directe dont la réponse figure explicitement dans la source.
2. Une reformulation utilisant des mots différents.
3. Une question limite à laquelle la source ne répond pas.
4. Un fait récemment modifié.
5. Une variante linguistique pour chaque langue configurée de l'agent.

Le bon résultat n'est pas toujours une réponse assurée. Lorsque la source ne contient pas le fait, l'agent doit suivre ses instructions de repli ou d'escalade plutôt que d'en inventer un. Après le lancement, consultez **Conversations** pour repérer les questions sans réponse récurrentes et transformez les réponses validées en source ou en FAQ structurée.

## Dépannage [#dépannage]

| Symptôme                                                                       | À vérifier                                                                                                                                                              |
| ------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| L'URL signale l'absence de texte utilisable                                    | Accès public, type de contenu pris en charge, texte rendu côté serveur, cible de redirection et taille de la page                                                       |
| Le PDF signale l'absence de texte sélectionnable                               | S'il s'agit d'un scan ; appliquez-lui l'OCR ou exportez-le en PDF recherchable ou en fichier texte                                                                      |
| Fichier refusé car protégé par mot de passe ou ne correspondant pas à son type | Supprimez le mot de passe, puis enregistrez de nouveau le fichier dans son format réel au lieu de le renommer ; enregistrez les fichiers Office avec macros sans macros |
| L'importation YouTube/podcast échoue                                           | URL publique, disponibilité des sous-titres/de l'audio, clé du fournisseur de transcription et restrictions de récupération                                             |
| Un fait correct est ignoré                                                     | Résultat du traitement, formulation, sources contradictoires, ancienneté de la source et question de test exacte                                                        |
| L'agent en révèle trop                                                         | Supprimez immédiatement la source privée, puis renforcez les limites du persona et les accès au compte                                                                  |
| Une ancienne réponse persiste                                                  | Supprimez ou remplacez la source obsolète, attendez la réindexation et démarrez une nouvelle conversation de test                                                       |

N'importez jamais d'identifiants, de clés privées, d'exports clients non restreints, de dossiers médicaux ni aucun contenu que l'agent public ne doit jamais révéler.

---

# Consultations

Source: /fr/docs/build/lookups.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/security&#x22;, label: &#x22;Clients connectés&#x22;, icon: &#x22;shield&#x22; },
{ href: &#x22;/fr/docs/build/knowledge&#x22;, label: &#x22;Sources de connaissances&#x22;, icon: &#x22;book&#x22; }
]"
/>

## Quand utiliser une consultation [#quand-utiliser-une-consultation]

Utilisez une consultation pour obtenir l'état actuel d'une commande, une réservation existante ou la fiche de compte d'un client. Conservez les politiques stables et les informations produit dans les [Sources](/fr/docs/build/knowledge). Une consultation lit votre système ; elle ne doit pas facturer, annuler, réserver ni modifier un enregistrement de quelque manière que ce soit. Les cartes génériques de choix et de confirmation envoient uniquement un message du visiteur. Pour les écritures confirmées, utilisez les [Actions de modification](/fr/docs/build/change-actions) ; pour les réservations de calendrier, utilisez la [réservation avec Cal.com](/fr/docs/build/cal-com). Seules les cartes de confirmation adossées à une exécution autorisent ces opérations.

## Configurer l'action [#configurer-laction]

Ouvrez **Agent → Actions**. Créez le secret dans **Clients connectés**, stockez-le sur votre serveur et mettez en œuvre l'[identification des clients](/fr/docs/embed/security#identify-signed-in-customers). Dans **Consultations**, ajoutez un nom tel que `order_status`, expliquez quand l'agent doit l'utiliser et saisissez votre endpoint HTTPS public. Ne déclarez que les entrées dont vous avez besoin, par exemple une chaîne `order_id`. L'agent voit cet outil sous le nom `lookup_order_status`.

Laissez activée l'option **Client connecté requis** pour les fiches privées (valeur par défaut). Si elle est désactivée, les requêtes peuvent contenir `customer: null` ; ne renvoyez alors que des informations adaptées à un visiteur anonyme. Un identifiant mentionné dans le chat ou extrait d'une photo est une entrée, et non une identité authentifiée.

Les champs existants sont enregistrés automatiquement ; attendez l'indicateur d'enregistrement avant de tester. Vous pouvez activer/désactiver, modifier ou supprimer une consultation. Le panneau nécessite qu'un secret soit configuré. Ces actions se configurent dans le tableau de bord ; la vague 1 n'expose pas la gestion des consultations via l'API publique.

## La requête que vous recevez [#la-requête-que-vous-recevez]

Make Agent Fast envoie une requête POST JSON à l'URL que vous avez configurée. Les exemples ci-dessous utilisent des valeurs de signature fictives :

```http
POST /agent/order-status HTTP/1.1
Content-Type: application/json
x-maf-timestamp: <unix-seconds>
x-maf-signature: v1=<64-lowercase-hex-characters>
```

```json
{
  "version": 1,
  "action": "order_status",
  "requestId": "c5c1d94b-e88f-4bf6-8023-2dcd1e7ac67b",
  "siteId": "YOUR_SITE_ID",
  "input": { "order_id": "A128" },
  "customer": { "id": "customer_123", "email": "customer@example.com" }
}
```

`action` correspond au nom configuré, sans le préfixe `lookup_`. `requestId` identifie cette tentative ; `siteId` identifie votre site. `input` ne contient que les paramètres de type chaîne déclarés. `customer` vaut soit null, soit l'objet `{ id, email?, name? }` vérifié côté serveur ; les entrées du visiteur ou du modèle ne peuvent pas le remplacer. Le bouton **Tester** du tableau de bord utilise volontairement le client fictif saisi par un propriétaire autorisé.

## Vérifier la signature [#vérifier-la-signature]

La signature est un HMAC-SHA256 en hexadécimal minuscule, calculé avec votre **secret d'agent** et préfixé par `v1=`. Signez exactement `"maf-webhook-v1:" + timestamp + "." + rawBody`. Conservez les octets reçus : analyser puis resérialiser le JSON avant de vérifier la signature peut les modifier. Cette fonction utilitaire accepte une `Request` serveur standard, applique une fenêtre de validité de cinq minutes et verrouille le site :

```js
import { createHmac, timingSafeEqual } from "node:crypto";

export async function verifyLookupRequest(request, expectedSiteId) {
  const secret = process.env.MAF_SECRET_KEY;
  if (!secret) throw new Error("MAF_SECRET_KEY is required");
  const timestamp = request.headers.get("x-maf-timestamp");
  const signature = request.headers.get("x-maf-signature");
  const now = Math.floor(Date.now() / 1000);
  if (!timestamp || !/^\d+$/.test(timestamp) ||
      !Number.isSafeInteger(Number(timestamp)) ||
      Math.abs(now - Number(timestamp)) > 300) {
    throw new Error("Invalid timestamp");
  }
  if (!signature || !/^v1=[a-f0-9]{64}$/.test(signature)) {
    throw new Error("Invalid signature");
  }
  const rawBody = Buffer.from(await request.arrayBuffer());
  const expected = createHmac("sha256", secret)
    .update(`maf-webhook-v1:${timestamp}.`)
    .update(rawBody)
    .digest();
  const actual = Buffer.from(signature.slice(3), "hex");
  if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
    throw new Error("Invalid signature");
  }
  const body = JSON.parse(rawBody.toString("utf8"));
  if (body?.version !== 1 || body.siteId !== expectedSiteId) {
    throw new Error("Invalid lookup scope");
  }
  return body;
}
```

Appelez-la avant que votre analyseur de corps (body parser) ne consomme la requête. Votre gestionnaire doit rejeter les erreurs de vérification, valider l'action attendue et la forme des entrées, puis contrôler l'appartenance de l'enregistrement à `body.customer.id` avant de renvoyer des données privées. Par exemple, sélectionnez la commande A128 **parmi les commandes de ce client**, et non à partir de son seul identifiant de commande. N'utilisez jamais `input.customer_id`, un e-mail fourni dans le chat ou une photo comme autorisation. Exigez un client non null pour les endpoints privés. Limitez la taille du corps des requêtes entrantes sur votre serveur et suivez les `requestId` pendant la fenêtre de validité si vous souhaitez rejeter les rejeux ; la vérification de l'horodatage seule ne rejette pas un rejeu intervenant dans cette fenêtre.

Utilisez HTTPS et gardez cet endpoint en lecture seule, même si le transport se fait en POST. Après une rotation du secret d'agent, mettez à jour à la fois votre serveur de signature d'identité et votre vérificateur de consultations.

## Renvoyer une réponse [#renvoyer-une-réponse]

Répondez avec un statut 2xx et un JSON conforme à ce contrat. Le premier exemple correspond à un enregistrement trouvé ; le second à un résultat normal sans correspondance :

```json
{
  "found": true,
  "card": {
    "title": "Order #A128",
    "status": { "label": "Shipped", "tone": "success" },
    "fields": [{ "label": "Carrier", "value": "DHL" }],
    "reference": "A128",
    "asOf": "2026-10-12T09:00:00Z",
    "link": { "label": "Track", "url": "https://shop.example.com/orders/A128" }
  },
  "facts": { "order_id": "A128", "status": "shipped", "carrier": "DHL" }
}
```

```json
{ "found": false }
```

`found` est obligatoire. Pour `found: true`, incluez `card`, `facts` ou les deux. Une carte requiert `title` et `fields` (un tableau vide est autorisé). Les champs facultatifs sont `status`, `reference`, `asOf` et `link`. N'ajoutez pas `kind` à la carte de la réponse. Les tons de statut sont `neutral`, `success`, `warning` et `danger`. Utilisez un horodatage ISO pour `asOf` et un lien HTTPS sans identifiants intégrés. Les liens facultatifs invalides sont omis.

`facts` est un objet plat dont les valeurs sont des chaînes, des nombres finis, des booléens ou null ; les objets imbriqués et les tableaux sont rejetés. Les champs inconnus dans le schéma de réponse ou de carte sont rejetés. Ne renvoyez que les informations nécessaires pour répondre : le modèle reçoit des données échappées et bornées, signalées comme non fiables, et non des instructions. Le contenu de la carte est du texte brut, pas du HTML.

## Limites et comportement en cas d'échec [#limites-et-comportement-en-cas-déchec]

| Élément                                           | Limite                                                                                                                  |
| ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| Consultations par agent                           | 5 ; noms et identifiants uniques                                                                                        |
| Nom                                               | `^[a-z][a-z0-9_]{2,39}$` ; les noms d'action réservés ne sont pas disponibles                                           |
| Description                                       | 300 caractères                                                                                                          |
| Entrées déclarées                                 | 3 ; noms uniques correspondant à `^[a-z][a-z0-9_]{1,31}$`                                                               |
| Descriptions / valeurs des entrées                | 300 / 200 caractères ; les valeurs sont tronquées des espaces superflus                                                 |
| Endpoint                                          | HTTPS public, jusqu'à 500 caractères, sans identifiants ; adresses privées/internes bloquées ; redirections non suivies |
| Délai d'attente / corps de la réponse             | 8 secondes / 32 KiB (32 768 octets)                                                                                     |
| Données du modèle                                 | 2 000 caractères, distinctes de la carte du visiteur                                                                    |
| Titre / libellés / valeurs des champs de la carte | 80 / 40 / 200 caractères                                                                                                |
| Champs de la carte                                | 8 ; au maximum 3 cartes par tour de l'agent                                                                             |

L'absence d'identité client produit un avertissement de connexion sans appeler votre endpoint. Si des entrées requises manquent, l'agent les demande au visiteur. `found: false` affiche une carte neutre indiquant l'absence de résultat. Les délais dépassés, les statuts non 2xx, les JSON ou schémas invalides et les réponses trop volumineuses affichent un statut d'échec et indiquent au modèle de ne pas deviner. Pour un enregistrement simplement absent, renvoyez `found: false` avec un statut 2xx plutôt qu'un HTTP 404. Gardez les faits importants concis : les chaînes de carte et les données du modèle en excès sont tronquées.

## Tester depuis le tableau de bord [#tester-depuis-le-tableau-de-bord]

1. Enregistrez la consultation et ouvrez **Tester**. Saisissez un identifiant client fictif, un e-mail facultatif et toutes les entrées requises. Utilisez un compte que vous contrôlez.
2. Lancez **Tester**. Cela envoie une véritable requête signée, même si la consultation est désactivée pour les visiteurs ; le chat de répétition ordinaire n'appelle jamais l'endpoint. Le tableau de bord limite le nombre de tentatives de test par propriétaire.
3. Examinez la carte/le résumé validé ou l'erreur, l'identifiant de requête, la durée et le statut HTTP lorsqu'ils sont disponibles. Consultez les journaux de votre endpoint sans y enregistrer de secrets ni de jetons client.
4. Testez les cas suivants : trouvé, non trouvé, mauvais compte, entrée manquante et délai dépassé. Testez ensuite l'intégration réelle avec deux clients authentifiés ; un client fictif du tableau de bord ne prouve ni l'isolation de l'identité dans le navigateur, ni la sélection réelle de l'outil par le modèle.

Le widget affiche des cartes de statut ; les appuis sur les choix et confirmations génériques envoient leurs libellés sous forme de messages. Les confirmations de modification et de réservation adossées à une exécution utilisent à la place le flux d'exécution protégé. Les connecteurs adaptent les cartes en texte/cartes natifs et en boutons, réponses rapides ou listes, avec un repli en texte, dans la limite des contraintes de chaque canal. Testez chaque canal visé avant de vous appuyer sur la livraison.

---

# Vos propres outils (MCP)

Source: /fr/docs/build/mcp-tools.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/change-actions&#x22;, label: &#x22;Confirmations et approbations&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: &#x22;Identité du client&#x22;, icon: &#x22;book&#x22; }
]"
/>

## Connecter et découvrir [#connecter-et-découvrir]

Ouvrez **Agent → Actions → Vos outils (MCP)**. Connectez votre serveur distant à l'aide de son flux OAuth ou d'un identifiant bearer, ou utilisez une connexion MCP existante. Choisissez **Découvrir** pour lire le catalogue d'outils. Examinez la description, les paramètres et les annotations de chaque outil avant de l'activer. La découverte n'exécute aucun outil ; les outils nouvellement découverts sont désactivés.

Vous pouvez configurer trois serveurs d'outils et activer 20 outils au total. Les identifiants restent côté serveur. La suppression d'un mappage d'outil arrête ce mappage, mais ne révoque pas la connexion de connaissances partagée ni son autorisation OAuth ; gérez cette connexion séparément. Le serveur MCP de gestion propriétaire de Make Agent Fast ne peut pas être exposé comme serveur d'outils pour les clients. Pour gérer vos agents depuis Claude, consultez [Utiliser Claude et ChatGPT](/fr/docs/operate/ai-assistants).

## Choisir lecture ou écriture [#choisir-lecture-ou-écriture]

| Effet    | Comportement                                                                                                            |
| -------- | ----------------------------------------------------------------------------------------------------------------------- |
| Lecture  | Appelle directement l'outil et traite le texte ou les données structurées renvoyés comme des données métier non fiables |
| Écriture | Crée une proposition ; le client doit confirmer les entrées exactes à l'aide des boutons de la carte avant l'exécution  |

La lecture n'est disponible que si le serveur déclare `readOnlyHint: true` et ne déclare pas `destructiveHint: true`, et si vous conservez l'outil classé en lecture. Sinon, traitez-le comme une écriture. Vérifiez ce que le serveur fait réellement ; les annotations ne constituent pas un système d'autorisation.

Par défaut, les écritures exigent à chaque fois l'approbation du propriétaire. Vous pouvez choisir de n'exiger aucune approbation supplémentaire du propriétaire, ou une approbation au-delà d'une limite portant sur un paramètre numérique. La confirmation du client reste requise dans tous les modes. L'approbation du propriétaire utilise la liste des approbations et les reçus existants. Les paramètres sont enregistrés automatiquement. La répétition côté propriétaire n'appelle jamais le serveur distant.

## Associer le client connecté [#associer-le-client-connecté]

Par défaut, les outils exigent un client vérifié. Utilisez l'[identité client signée](/fr/docs/embed/security) sur votre site web ; un identifiant saisi dans le chat ne constitue pas une vérification. Pour les enregistrements propres à un client, choisissez le paramètre de type chaîne de l'outil qui identifie le client. Le serveur le renseigne à partir de l'identifiant client vérifié et le retire des entrées du modèle. Les paramètres de type enum ne peuvent pas être utilisés pour cette association.

Par exemple, associez `customer_id` sur un outil qui lit une commande. Le modèle peut fournir la référence de commande déclarée, mais ne peut pas substituer l'identifiant d'un autre client. Le serveur distant doit tout de même vérifier que la commande appartient bien à ce client. Exiger la connexion sans association de paramètre ne limite pas, à lui seul, tous les enregistrements auxquels l'outil distant peut accéder.

## Limites et résultats incertains [#limites-et-résultats-incertains]

Les schémas pris en charge sont des objets plats comportant jusqu'à dix paramètres de type chaîne, nombre, entier, booléen ou enum. Les objets imbriqués, les tableaux et les règles de schéma non prises en charge restent indisponibles. Les chaînes sont limitées à 200 caractères ; les appels distants ont un délai d'expiration de 10 secondes et les résultats visibles par le modèle sont plafonnés à 4 Ko. Le contenu d'un résultat est une donnée, jamais une instruction pour l'agent.

MCP n'offre aucune garantie générale d'idempotence. Une écriture n'est appelée qu'une seule fois après confirmation ou approbation. Si son résultat est inconnu, Make Agent Fast ne réessaie pas automatiquement et en informe le propriétaire. Vérifiez le système distant avant de créer une autre proposition. Modifier la configuration d'un outil déjà examiné invalide toute proposition plus ancienne.

Testez chaque lecture et chaque écriture prévues avec votre propre serveur avant que les clients ne les utilisent.

---

# Actions de page

Source: /fr/docs/build/page-actions.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/html&#x22;, label: &#x22;Installer l'intégration&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/build/follow-ups&#x22;, label: &#x22;Relances&#x22;, icon: &#x22;book&#x22; }
]"
/>

## Enregistrer une action côté site [#enregistrer-une-action-côté-site]

Les actions de page permettent au site web d'ouvrir sa propre interface ou de naviguer vers une page approuvée. Installez l'intégration (embed) dans sa version actuelle, puis lancez l'enregistrement une fois le script chargé. Conservez les gestionnaires dans votre application : l'agent reçoit uniquement leurs noms, leurs descriptions et la définition de leurs paramètres, jamais le code des gestionnaires.

```js
MakeAgentFast.registerAction("show_details", {
  description: "Show the details section on this page",
  params: { section: { type: "string", description: "Use delivery or returns" } },
  confirm: true
}, async ({ section }) => {
  const sections = {
    delivery: document.getElementById("delivery-details"),
    returns: document.getElementById("returns-details")
  };
  if (!Object.hasOwn(sections, section) || !sections[section]) {
    throw new Error("Unknown section");
  }
  sections[section].scrollIntoView({ block: "start" });
  return { shown: section };
});

// Run when the page component unmounts:
// MakeAgentFast.unregisterAction("show_details");
```

Les deux méthodes renvoient un booléen indiquant si l'enregistrement ou la suppression a été accepté. Les noms utilisent des lettres minuscules, des chiffres et des tirets bas (underscores), commencent par une lettre et comptent de 2 à 40 caractères. Il existe neuf emplacements d'enregistrement personnalisés, plus l'action intégrée `open_page`. Chaque définition autorise cinq paramètres de type chaîne ; tous les paramètres déclarés sont obligatoires, avec des valeurs allant jusqu'à 200 caractères. Les descriptions sont limitées à 200 caractères. Un gestionnaire peut renvoyer une chaîne ou une valeur sérialisable en JSON, jusqu'à 2 Ko, en moins de 10 secondes.

## Approuver les actions dans le tableau de bord [#approuver-les-actions-dans-le-tableau-de-bord]

Ouvrez le site web sur lequel l'intégration est installée afin qu'il signale les noms et descriptions de ses actions, puis ouvrez **Agent → Actions → Actions de page**. Activez la fonctionnalité et autorisez chacune des actions prévues. Les descriptions signalées sont des métadonnées du site web non fiables ; la détection n'approuve rien. Les paramètres sont enregistrés automatiquement.

L'agent ne peut proposer que les actions qui sont à la fois actuellement enregistrées et autorisées. Le customer voit une carte avant l'exécution. Une confirmation est requise, sauf si l'owner marque l'action comme sûre ; `confirm: true` dans le code de votre site exige toujours un appui de la part du customer. `confirm: false` seul ne contourne pas la politique de l'owner. Réservez le mode sûr aux modifications d'interface sans conséquence.

L'action intégrée `open_page` n'a besoin d'aucun gestionnaire. Autorisez-la dans le tableau de bord ; elle accepte un chemin relatif ou une URL HTTP(S) appartenant aux origines de site web autorisées de l'agent. Les chemins relatifs exigent également que l'origine du site web actuel soit autorisée. Elle ne peut pas rediriger vers une destination externe arbitraire.

## Signaler un événement avec track [#signaler-un-événement-avec-track]

```js
MakeAgentFast.track("form_error", { formId: "contact" });
MakeAgentFast.track("checkout_help", { step: "delivery" });
```

Appelez ces méthodes après le chargement de l'embed, et uniquement lorsque l'événement correspondant se produit réellement. Configurez un nom d'événement correspondant dans [Relances](/fr/docs/build/follow-ups). Les noms suivent le même format de 2 à 40 caractères ; les données facultatives doivent être un objet JSON d'au plus 1 Ko. N'envoyez pas de valeurs de champs, d'identifiants ni de données de paiement. Les règles s'appliquent selon l'événement, le chemin et le délai ; les métadonnées ne sont ni stockées, ni transmises au modèle, ni utilisées comme preuve de conversion. Un retour `true` signifie que le loader a accepté l'événement, et non qu'un message a été affiché.

## Sécurité et vérification [#sécurité-et-vérification]

Les actions de page fonctionnent dans le widget du site web en production, mais pas dans les channels de messagerie, ni dans les essais de l'owner, ni en voix en direct. Le loader et la frame vérifient l'origine, la source, le slug et les identifiants des requêtes en attente. Les résultats reviennent dans le chat en tant que données de navigateur non fiables, et non comme preuve qu'un enregistrement côté serveur a été modifié. Conservez l'authentification et l'autorisation dans vos propres gestionnaires et votre propre backend ; utilisez les [Actions de modification](/fr/docs/build/change-actions) pour les écritures métier ayant des conséquences.

Un délai dépassé n'annule pas le gestionnaire et ne prouve pas qu'il ne s'est rien passé. Ne relancez pas automatiquement une action dont le résultat est incertain. Désenregistrez les gestionnaires lorsque leur composant de page quitte l'écran. Les embeds déjà en cache nécessitent la version actuelle du loader, `20261014-page-actions`, pour cette API.

Cette API ne gère pas les paiements et ne fournit pas de connector Shopify.

---

# Persona et instructions

Source: /fr/docs/build/persona.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Règles de persona&#x22;, icon: &#x22;account&#x22; }, { label: &#x22;Limites&#x22;, icon: &#x22;shield&#x22; }, { label: &#x22;Langues&#x22;, icon: &#x22;globe&#x22; }]" />

## Séparer l'identité des connaissances [#séparer-lidentité-des-connaissances]

Il n'existe pas de page Persona distincte. Rédigez les instructions de l'agent dans l'onglet **Vue d'ensemble** de la page de l'agent, dans le champ **Instructions** ; elles sont enregistrées automatiquement.

La persona définit qui est l'agent et comment il se comporte. Les connaissances fournissent les faits. Indiquez « Parlez en tant qu'assistant du support Acme » dans la persona ; placez la durée de garantie en vigueur dans une source de connaissances.

## Ordre des instructions [#ordre-des-instructions]

Rédigez les instructions dans cet ordre :

1. Identité et rôle
2. Objectif principal du visiteur
3. Ton et longueur des réponses
4. Actions et questions obligatoires
5. Affirmations interdites et sujets sensibles
6. Conditions d'escalade et de capture de leads

## Limites [#limites]

Indiquez à l'agent quand il doit dire qu'il ne sait pas, quand citer ou nuancer une réponse, et quand proposer l'aide d'un humain. Ne lui demandez jamais de masquer son incertitude ni d'inventer des données manquantes.

## Tester les modifications [#tester-les-modifications]

Les modifications de la persona peuvent affecter tous les channels. Testez à nouveau les questions courantes, les refus, la capture de leads et les langues prises en charge avant de publier une modification importante.

---

# Voix et appels en direct

Source: /fr/docs/build/voice.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ label: &#x22;Voix prédéfinies&#x22;, icon: &#x22;voice&#x22; },
{ label: &#x22;Messages vocaux&#x22;, icon: &#x22;message&#x22; },
{ label: &#x22;Appels en direct&#x22;, icon: &#x22;bolt&#x22; }
]"
/>

## Comprendre les trois modes d'interaction [#comprendre-les-trois-modes-dinteraction]

| Mode                              | Expérience du visiteur                                                                                                     | Droits et utilisation                                                                                                                           |
| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| **Chat texte**                    | Saisit un message et reçoit une réponse écrite                                                                             | Toujours activé ; consomme des crédits d'IA normaux                                                                                             |
| **Messages vocaux**               | Enregistre un message, attend la transcription, la réponse de l'agent et la synthèse vocale (TTS), puis reçoit une réponse | Inclus dans tous les forfaits ; la transcription, le modèle et le travail de synthèse vocale consomment des crédits                             |
| **Appel en direct en temps réel** | Tient une conversation orale à faible latence                                                                              | Operate : 30 min/mois ; Scale : 90 min/mois ; Launch : indisponible ; débite également à l'avance des crédits pour la limite d'appel configurée |

Le texte ne peut pas être désactivé. Les options Messages vocaux et Temps réel déterminent quelles surfaces supplémentaires les visiteurs peuvent utiliser. Une option temps réel enregistrée ne remplace ni les droits du forfait de l'espace de travail, ni une configuration de fournisseur manquante.

## Configurer le comportement des interactions [#configurer-le-comportement-des-interactions]

1. Ouvrez la page **Agent** du site et repérez la section **Voix**.
2. Laissez **Chat texte** activé et choisissez **Messages vocaux** et/ou **Voix en direct en temps réel**.
3. Si l'agent gère plusieurs langues, activez éventuellement le mode miroir de langue en direct.
4. Définissez la limite automatique par appel.
5. Sélectionnez une voix prédéfinie.
6. Enregistrez, puis testez séparément chaque mode activé.

La limite d'appel accepte des valeurs de 30 secondes à 20 minutes, par paliers de 30 secondes ; la valeur par défaut est de 3 minutes. Elle met fin à un appel individuel et protège le quota mensuel, mais elle n'augmente pas les minutes en direct restantes du forfait.

## Choisir les langues et une voix [#choisir-les-langues-et-une-voix]

Les agents peuvent être configurés pour l'anglais, le coréen, l'ouzbek, le russe, le français, l'espagnol, l'allemand et l'arabe. La première langue est la langue principale. Un agent monolingue continue de répondre dans cette langue. Un agent texte multilingue s'adapte à la langue du visiteur lorsque celui-ci utilise l'une des langues configurées.

Pour les appels en direct, le mode miroir de langue est une option explicite, affichée uniquement lorsque deux langues ou plus sont configurées. Lorsqu'il est désactivé, les appels en direct utilisent la langue principale. La voix ouzbèke fonctionne actuellement au mieux (« best effort »), car la couverture vocale des fournisseurs est moins complète ; testez-la avec votre fournisseur et votre public exacts avant le lancement.

Les voix prédéfinies comprennent des options axées sur l'anglais, multilingues et natives coréennes. L'étiquette de langue décrit la diction sélectionnée, et non une garantie absolue. Écoutez un aperçu de la voix choisie lorsque la commande d'aperçu du tableau de bord est disponible, et testez toujours les noms, abréviations, devises, numéros de téléphone et termes spécialisés dans le parcours réel du visiteur.

## Clés de fournisseur et solution de repli [#clés-de-fournisseur-et-solution-de-repli]

La voix nécessite plus qu'une clé de modèle :

* La reconnaissance vocale (speech-to-text) utilise le fournisseur de transcription configuré par la plateforme.
* Les messages vocaux et les réponses audio des connecteurs nécessitent le fournisseur de synthèse vocale (TTS) configuré.
* Les appels en temps réel nécessitent le fournisseur temps réel configuré et un quota inclus dans le forfait.

La voix gérée par la plateforme utilise les fournisseurs configurés par la plateforme ; vous n'avez pas besoin de clé. Les propriétaires d'un forfait Scale peuvent éventuellement ajouter une clé Speko pour la transcription et la synthèse vocale dans **Paramètres → Clés de fournisseur d'IA** et suivre [Clés de fournisseur](/fr/docs/account/provider-keys). Les appels en direct sont toujours facturés au tarif de la plateforme. Un chat texte réussi prouve uniquement que le chemin du modèle fonctionne ; il ne prouve ni la transcription, ni la synthèse vocale, ni l'envoi de médias, ni la création de sessions en temps réel.

## Routage vocal et solution de repli [#routage-vocal-et-solution-de-repli]

Choisissez un modèle sous **Modèles vocaux** pour la transcription, la synthèse vocale et les appels en direct. Chaque choix indique le modèle et son créateur ; **Auto** nous laisse choisir. L'hébergement et le routage sont gérés par Make Agent Fast, il n'y a donc pas de choix de plateforme distinct. La voix prédéfinie exacte peut varier selon le modèle sélectionné.

Si un service vocal est indisponible, une solution de secours disponible peut être utilisée. Si la voix échoue, le texte reste disponible.

Les appels en direct diffusent un audio natif depuis le fournisseur en direct sélectionné, en utilisant sa voix intégrée. La récupération de connaissances, les règles de langue, l'interruption, les quotas de minutes en direct et les débits initiaux d'appel s'appliquent toujours. Les réponses en direct n'effectuent pas de requête TTS supplémentaire.

## Tester les messages vocaux [#tester-les-messages-vocaux]

Utilisez une vraie intégration ou l'Agent link, et pas seulement un aperçu propriétaire. Accordez l'accès au microphone, enregistrez une courte question et vérifiez le sens de la transcription ainsi que la réponse vocale/écrite. Testez ensuite :

* des environnements calmes et bruyants ;
* Safari mobile et Chrome, le cas échéant ;
* une longue question proche de la limite publique de 25 Mo pour l'audio ;
* un refus d'autorisation du microphone ;
* un audio non pris en charge ou de mauvaise qualité ;
* chaque langue configurée.

Pour les sites avec intégration, la CSP et la Permissions Policy du site parent doivent autoriser l'utilisation du microphone. Consultez [Sécurité et CSP](/fr/docs/embed/security).

## Conversation en direct sur la plateforme et sur le site publié [#conversation-en-direct-sur-la-plateforme-et-sur-le-site-publié]

La conversation en direct utilise les mêmes commandes d'appel à deux endroits :

| Surface                        | Emplacement                                                                                      | Apparence                                                        | Compte comme activation ?                              |
| ------------------------------ | ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------- | ------------------------------------------------------ |
| **Canevas du studio d'agent**  | Le widget en direct à côté des onglets de la page **Agent**                                      | L'apparence du widget visiteur, affichée dans le tableau de bord | Non — les tests du propriétaire n'activent jamais      |
| **Site publié et intégration** | L'iframe `embed.js`, le widget sur l'Agent link et toute page de démonstration hébergée restante | Apparence du locataire / du widget                               | Oui — l'appel d'un visiteur est une vraie conversation |

Le canevas à côté de l'onglet **Affichage** montre la même apparence que celle du visiteur. Testez une vraie intégration avant le lancement ; un test réussi dans le tableau de bord ne prouve ni l'autorisation du microphone dans l'intégration, ni la CSP de la page hôte, ni l'activation.

**Utiliser le site web** sous **Thème de l'agent** dans l'onglet **Affichage** suit le mode clair ou sombre du visiteur sur la page hôte et l'intégration. Un réglage fixe Clair ou Sombre s'applique à la fois au chat et à l'appel en direct. Consultez [Apparence](/fr/docs/build/appearance).

## Tester les appels en direct [#tester-les-appels-en-direct]

Vérifiez que le forfait dispose de minutes en direct non utilisées, que le site est accessible et que la clé du fournisseur temps réel est valide. Commencez par un appel court, interrompez l'agent, ne changez de langue que si le mode miroir est activé, et laissez la limite d'appel configurée mettre fin à une session de test. Répétez un appel sur une vraie intégration, et pas seulement sur le canevas de la page Agent.

Les minutes en direct constituent un droit mensuel distinct des crédits normaux. L'émission du jeton en direct débite des crédits pour la durée maximale autorisée par le serveur et réserve cette durée sur le quota mensuel de minutes en direct. Comme les médias circulent directement entre le navigateur et le fournisseur, un appel plus court déclaré par le client ne peut pas être vérifié et le temps inutilisé n'est pas remboursé partiellement après la remise du jeton. Les échecs de création de jeton côté serveur sont libérés ; les sessions abandonnées sont facturées à leur limite autorisée. Terminez proprement vos tests et utilisez la limite d'appel configurée pour vos prévisions. Consultez [Crédits et utilisation](/fr/docs/operate/usage).

## Actions en voix directe [#actions-en-voix-directe]

**Agent → Actions → Actions pendant les appels en direct** (**Autoriser l'agent à effectuer des actions pendant les appels en direct**) contrôle l'utilisation des outils pendant les appels en direct, qui s'exécutent sur Gemini 3.8 Live dans toutes les langues. Cette option est activée par défaut (`voice.liveActions`) ; la désactiver laisse l'ancrage dans les connaissances disponible. Les exigences de forfait, de fournisseur et d'accès à la voix en direct continuent de s'appliquer.

Les appels peuvent afficher des résultats de recherche, des choix, des propositions de modification, des créneaux/réservations de calendrier, des suivis programmés et un handoff vers un humain. Les modifications de l'entreprise, les réservations et les suivis nécessitent l'utilisation des boutons des cartes à l'écran ; un « oui » prononcé ou saisi ne confirme jamais une écriture. Un suivi nécessite aussi le consentement par e-mail à l'écran. Les cartes et les résultats d'outils restent dans l'historique de la conversation. Les actions de page et vos propres outils MCP ne font pas partie du sous-ensemble disponible en direct. La facturation des appels reste en mode réservation seule, sans remboursement du temps d'appel inutilisé après la remise du jeton.

Testez à la fois le résultat vocal et la confirmation à l'écran avant toute utilisation par des clients. Consultez [Suivis](/fr/docs/build/follow-ups) et [Actions de modification](/fr/docs/build/change-actions).

## Information et sécurité [#information-et-sécurité]

Informez les appelants qu'ils interagissent avec une IA et une voix synthétique. Définissez la manière dont les enregistrements, les transcriptions et les données des fournisseurs en aval sont conservés et supprimés.

## Dépannage [#dépannage]

| Symptôme                                                | À vérifier                                                                                                                                      |
| ------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| Le texte fonctionne mais les commandes vocales échouent | Clés des fournisseurs de transcription/TTS/temps réel, activation de la fonctionnalité, forfait, solde de crédits et autorisation du navigateur |
| L'enregistrement ne peut pas démarrer                   | HTTPS, autorisation du microphone, entrée de l'appareil, Permissions Policy de l'intégration et prise en charge par le navigateur               |
| La transcription est inexacte                           | Qualité audio, ensemble de langues choisi, accent/terminologie et couverture du fournisseur de transcription                                    |
| La réponse vocale sonne mal                             | Voix sélectionnée, texte source, ponctuation, étiquette de langue et disponibilité du fournisseur                                               |
| L'appel en direct se termine immédiatement              | Minutes restantes, limite par appel, clé du fournisseur, réseau et état des sessions simultanées                                                |

Traitez la voix comme une surface de lancement à part entière : les tests de recette du texte sont nécessaires, mais pas suffisants.

---

# Discord

Source: /fr/docs/connectors/discord.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/connectors/overview&#x22;, label: &#x22;Tous les connecteurs&#x22;, icon: &#x22;connectors&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Boîte de réception&#x22;, icon: &#x22;message&#x22; },
{ label: &#x22;Discord&#x22;, icon: &#x22;discord&#x22; }
]"
/>

<TutorialVideo episode="ep09" start="89" />

## Créer l'application Discord [#créer-lapplication-discord]

Suivez le [guide de démarrage d'application](https://docs.discord.com/developers/quick-start/getting-started) officiel de Discord ainsi que sa [présentation des interactions](https://docs.discord.com/developers/interactions/overview). Créez une application dans le Discord Developer Portal et récupérez les éléments suivants :

| Champ Make Agent Fast | Emplacement dans Discord | Rôle                                                                             |
| --------------------- | ------------------------ | -------------------------------------------------------------------------------- |
| **Application ID**    | General Information      | Identifie l'application et la commande                                           |
| **Public Key**        | General Information      | Vérifie les interactions signées Ed25519 ; exactement 64 caractères hexadécimaux |
| **Bot token**         | Page Bot                 | Valide l'application et enregistre `/ask` ; à garder secret                      |

La réinitialisation d'un bot token invalide immédiatement le précédent. La Public Key n'est pas secrète, mais elle doit appartenir à la même application que le bot token.

## Connecter et enregistrer `/ask` [#connecter-et-enregistrer-ask]

Ouvrez la page **Canaux** de l'agent, choisissez **Discord**, saisissez les trois valeurs, puis sélectionnez **Connecter**.

Make Agent Fast valide le bot token auprès du point de terminaison d'application de Discord et rejette toute Public Key qui ne correspond pas à l'application. Il corrige un Application ID mal saisi en le remplaçant par l'ID réel de l'application authentifiée, puis crée ou met à jour la commande globale `/ask question` sans supprimer les autres commandes de l'application.

Après l'enregistrement, copiez l'**URL du point de terminaison des interactions** affichée dans **General Information → Interactions Endpoint URL** sur Discord, puis enregistrez. Discord envoie un `PING` signé ; Make Agent Fast valide la signature et renvoie le `PONG` requis.

## Installer et tester [#installer-et-tester]

Utilisez les paramètres d'installation de Discord pour autoriser l'application sur un serveur de test, avec les permissions requises pour les commandes d'application. La propagation des commandes globales peut prendre du temps.

Exécutez `/ask`, renseignez l'option obligatoire `question`, puis envoyez. Make Agent Fast accuse réception de l'interaction avant l'expiration du court délai imparti par Discord, exécute l'agent, puis modifie la réponse initiale différée. L'historique des conversations est limité à chaque utilisateur Discord, ce qui permet aux demandes `/ask` suivantes de conserver le contexte.

Le connecteur actuel ne prend en charge que le texte. Il ne lit ni les salons vocaux, ni les pièces jointes, ni les messages ordinaires des salons, ni les messages privés ; seule l'interaction `/ask` enregistrée parvient à l'agent.

## Renouveler ou déconnecter [#renouveler-ou-déconnecter]

Si le bot token a été exposé, réinitialisez-le dans Discord, mettez à jour le connecteur, puis vérifiez à nouveau `/ask`. Si l'application elle-même change, mettez à jour les trois valeurs ainsi que l'URL du point de terminaison des interactions pour cette application.

Désactiver ou supprimer le connecteur ne supprime ni l'application Discord ni la commande globale. Retirez l'application des serveurs et supprimez séparément les identifiants du fournisseur devenus inutiles lorsque vous la désactivez définitivement.

## Dépannage [#dépannage]

| Symptôme                                                | Solution                                                                                                                                                            |
| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Le connecteur rejette les champs                        | Utilisez le bot token et la Public Key de 64 caractères provenant de la même application                                                                            |
| Discord rejette le point de terminaison                 | Vérifiez que l'URL est en HTTPS public, collez le point de terminaison généré et enregistrez à nouveau les identifiants avant de réessayer                          |
| `/ask` est introuvable                                  | Vérifiez l'installation et l'autorisation de la commande, attendez la propagation globale, puis reconnectez pour l'enregistrer de nouveau                           |
| L'interaction indique que l'application n'a pas répondu | Vérifiez que le connecteur est activé et examinez les erreurs de Make Agent Fast et de Discord ; la validation de la signature du point de terminaison doit réussir |
| Les autres messages de discussion sont ignorés          | Comportement normal ; l'intégration ne traite que `/ask`                                                                                                            |
| La réponse est tronquée                                 | Les réponses de message Discord sont limitées à 2 000 caractères                                                                                                    |

N'exposez jamais le bot token dans du code côté client, des dépôts, des journaux ou des captures d'écran.

---

# Instagram

Source: /fr/docs/connectors/instagram.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/connectors/overview&#x22;, label: &#x22;Tous les connecteurs&#x22;, icon: &#x22;connectors&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Boîte de réception&#x22;, icon: &#x22;message&#x22; },
{ label: &#x22;Instagram&#x22;, icon: &#x22;instagram&#x22; }
]"
/>

<TutorialVideo episode="ep05" />

## Ce que fait ce connecteur [#ce-que-fait-ce-connecteur]

Vos clients envoient un **message direct** à votre compte professionnel Instagram. Make Agent Fast répond avec le même agent fondé sur vos sources que celui de votre widget de site web, via l'[API Instagram avec connexion Instagram](https://developers.facebook.com/docs/instagram-platform/instagram-api-with-instagram-login) officielle de Meta.

Il peut aussi répondre aux **commentaires** de vos publications et de vos reels, publiquement ou par un DM privé (voir [Commentaires et réponses enregistrées](#commentaires-et-réponses-enregistrées)). Les réponses à vos stories sont également traitées (voir [Stories](#stories)). Hors périmètre : le scraping, ainsi que les « J'aime » sur les publications ou les commentaires. L'API officielle d'Instagram ne permet pas d'aimer un contenu, donc l'agent ne le fait jamais.

Chaque compte Instagram constitue son propre canal, ce qui permet de séparer la facturation, les fils de la boîte de réception et le routage des messages. Un agent peut gérer jusqu'à cinq comptes Instagram.

## Avant de commencer [#avant-de-commencer]

Vous avez besoin de :

1. Un compte Instagram **professionnel** (Business ou Créateur). Les comptes personnels ne peuvent pas être connectés ; passez en compte professionnel dans Instagram via **Paramètres → Type de compte et outils**.
2. Le nom d'utilisateur et le mot de passe Instagram du compte, ou une application Instagram déjà connectée à ce compte dans ce navigateur.
3. Le forfait Operate ou Scale pour ajouter un nouveau canal.

Vous n'avez **pas** besoin d'un compte Facebook, d'une Page Facebook, d'un portefeuille d'entreprise Meta ni d'une application développeur Meta.

## Connecter votre compte [#connecter-votre-compte]

### 1. Ouvrir la carte Instagram [#1-ouvrir-la-carte-instagram]

Dans le tableau de bord, ouvrez votre agent et allez dans **Canaux → Instagram**.

### 2. Se connecter et autoriser l'accès [#2-se-connecter-et-autoriser-laccès]

Sélectionnez **Se connecter avec Instagram**. Instagram ouvre sa propre page de connexion. Connectez-vous au compte professionnel pour lequel l'agent doit répondre, vérifiez que la fenêtre mentionne bien ce compte, puis sélectionnez **Autoriser**. Laissez activée l'option **Accéder aux messages et les gérer** ; sans elle, l'agent ne peut ni lire ni répondre aux DM. L'option **Accéder aux commentaires et les gérer** n'est utilisée que si vous activez ensuite les réponses aux commentaires.

Instagram vous redirige vers la carte Instagram, qui affiche désormais le compte comme connecté. Pour connecter un autre compte, sélectionnez à nouveau **Se connecter avec Instagram** et connectez-vous avec ce compte.

### 3. Envoyer un message de test [#3-envoyer-un-message-de-test]

Depuis un **autre** compte Instagram, envoyez un nouveau DM au compte connecté. Vérifiez que :

1. Le message apparaît dans votre boîte de réception Instagram.
2. La carte Instagram affiche un nouvel événement et que **Conversations** contient un nouveau fil.
3. L'étape de vérification de la carte est validée.

### 4. Activer les réponses de l'IA [#4-activer-les-réponses-de-lia]

Une fois le test réussi, activez les réponses de l'IA sur la carte. À partir de là, l'agent répond aux nouveaux DM. Les messages texte et les messages vocaux pris en charge reçoivent une réponse en texte. Vos propres messages, les images et les autres pièces jointes non prises en charge sont ignorés. Lorsque vous répondez vous-même depuis la boîte de réception **Conversations**, l'agent se met en pause pour cette conversation.

## Commentaires et réponses enregistrées [#commentaires-et-réponses-enregistrées]

Activez **Répondre aux commentaires** dans la section **Commentaires** de la carte Instagram. Les nouveaux commentaires de premier niveau sur vos publications et vos reels sont alors traités dans l'ordre suivant :

1. **Vos réponses enregistrées.** Rédigez une réponse pour une publication, ou pour **Toutes les publications**, et choisissez les mots-clés qui la déclenchent (par exemple `prix, combien`). Laissez les mots-clés vides pour répondre à tous les commentaires de cette publication. Chaque réponse enregistrée peut publier une réponse publique sous le commentaire, envoyer un DM privé, ou les deux. `{name}` est remplacé par le @pseudo de l'auteur du commentaire. Les réponses propres à une publication l'emportent sur celles de **Toutes les publications**, et les réponses à mots-clés l'emportent sur les réponses génériques. Les réponses enregistrées n'utilisent ni IA ni crédits.
2. **L'IA, si vous l'autorisez.** Sous **Si aucune réponse enregistrée ne convient**, choisissez **Rester silencieux**, **L'IA répond** (une ou deux phrases courtes, publiées publiquement) ou **L'IA envoie un DM** (la réponse est envoyée en DM à l'auteur du commentaire, avec, si vous le souhaitez, une phrase publique sous le commentaire). La légende de la publication est transmise à l'agent comme contexte. Les réponses de l'IA consomment des crédits, comme une réponse à un DM.

L'agent ne répond jamais à ses propres commentaires, ni à l'intérieur d'un fil de commentaires, ni aux commentaires qui se limitent à identifier des amis ou ne contiennent que des emojis, ni aux questions pour lesquelles il n'a aucune réponse approuvée. Les conversations issues des commentaires apparaissent dans **Conversations**, en lecture seule ; répondez-y directement sur Instagram. Instagram autorise un seul DM privé par commentaire, dans un délai de 7 jours.

## Stories [#stories]

Les stories parviennent à l'agent sous forme de DM :

* **Une réponse écrite à votre story** reçoit une réponse de l'IA comme n'importe quel DM. Lorsque la story est une photo, l'agent la voit : ainsi, « combien coûte ceci ? » obtient une réponse portant sur ce que montre la story. Les stories vidéo reçoivent une réponse basée uniquement sur le texte.
* **Une mention dans la story de quelqu'un** et **une réaction composée uniquement d'un emoji à votre story** ne contiennent aucune question, donc l'IA n'y répond jamais. Dans la section **Stories** de la carte Instagram, rédigez une courte réponse pour chacune, ou laissez le champ vide pour rester silencieux. Ces réponses n'utilisent ni IA ni crédits, et une même personne reçoit au maximum une réponse de réaction par jour.

Les trois cas apparaissent dans **Conversations**. Instagram n'informe pas les applications lorsqu'une personne aime une story, et aucune application ne peut aimer des stories ni les commenter.

## Disponibilité [#disponibilité]

**Se connecter avec Instagram** apparaît sur la carte une fois que Meta a approuvé l'accès de Make Agent Fast à la messagerie Instagram. D'ici là, la carte peut ne pas proposer ce bouton, et Instagram ne transmet que les messages des comptes que Meta autorise l'application à tester. Si le bouton n'apparaît pas encore sur votre carte, utilisez la méthode avancée ci-dessous ou revenez plus tard.

## Déconnecter ou reconnecter [#déconnecter-ou-reconnecter]

Make Agent Fast renouvelle automatiquement la connexion. Si les réponses s'arrêtent et que la carte affiche une erreur de connexion, par exemple après un changement de mot de passe, sélectionnez **Se reconnecter avec Instagram** et connectez-vous à nouveau. Pour déconnecter, supprimez la connexion sur la carte. Vous pouvez aussi retirer Make Agent Fast dans Instagram via **Paramètres → Applications et sites web** ; l'agent cesse alors immédiatement de répondre sur ce compte.

## Avancé : votre propre application Meta [#avancé--votre-propre-application-meta]

Les développeurs qui gèrent leur propre application Meta peuvent toujours se connecter avec un jeton d'accès de Page Facebook à la place. Cela nécessite un compte professionnel Instagram lié à une Page Facebook, une application développeur Meta disposant de `instagram_basic`, `instagram_manage_messages`, `pages_manage_metadata`, `pages_messaging` et `pages_show_list`, ainsi que la [configuration des webhooks](https://developers.facebook.com/docs/instagram-platform/instagram-api-with-facebook-login/webhooks/) de Meta.

Collez le **jeton d'accès de la Page** et la **clé secrète de l'application** dans le formulaire avancé de la carte, puis utilisez l'**URL du webhook** et le **jeton de vérification** affichés pour le webhook Instagram (champ `messages`). Abonnez la Page elle-même avec le jeton de la Page :

```text
POST /me/subscribed_apps?subscribed_fields=messages
```

Votre propre application ne peut répondre au public qu'après avoir passé l'App Review de Meta avec l'accès avancé (Advanced Access).

## Dépannage [#dépannage]

| Symptôme                                                  | Solution                                                                                                   |
| --------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| Aucun bouton **Se connecter avec Instagram**              | L'approbation de Meta est toujours en attente ; voir [Disponibilité](#disponibilité)                       |
| Instagram indique que le compte ne peut pas être utilisé  | Passez-le en compte professionnel (Business ou Créateur) et réessayez                                      |
| « Déjà connecté à un autre agent »                        | Déconnectez-le d'abord de cet agent, puis connectez-le ici                                                 |
| Connecté, mais aucun nouvel événement après un DM de test | Envoyez un nouveau DM depuis un autre compte ; les messages envoyés avant la connexion ne sont pas rejoués |
| Un DM arrive mais sans réponse                            | Activez les réponses de l'IA après l'étape de vérification et vérifiez si la carte affiche une erreur      |
| Les commentaires ne reçoivent pas de réponse              | Activez **Répondre aux commentaires** et ajoutez une réponse enregistrée ou autorisez les réponses de l'IA |
| Un message vocal reçoit une réponse en texte              | Comportement normal ; les réponses vocales Instagram ne sont pas prises en charge                          |
| La carte affiche une erreur de connexion                  | Sélectionnez **Se reconnecter avec Instagram** et connectez-vous à nouveau                                 |

Ne communiquez jamais votre mot de passe Instagram à qui que ce soit, y compris au support ; la connexion utilise le système de connexion propre à Instagram.

---

# KakaoTalk

Source: /fr/docs/connectors/kakao.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/connectors/overview&#x22;, label: &#x22;Tous les connecteurs&#x22;, icon: &#x22;connectors&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Boîte de réception&#x22;, icon: &#x22;message&#x22; },
{ label: &#x22;KakaoTalk&#x22;, icon: &#x22;kakao&#x22; }
]"
/>

<TutorialVideo episode="ep09" start="145" />

## Liste de contrôle de la configuration [#liste-de-contrôle-de-la-configuration]

La carte KakaoTalk de Make Agent Fast affiche cette liste avec vos propres valeurs déjà renseignées ; la plupart des propriétaires la suivent donc directement depuis cette carte. Toutes les étapes se déroulent dans la console de Kakao, à l'exception des deux champs indiqués ci-dessous.

1. **Créez un bot** dans Kakao i Open Builder. Un bot regroupe tous les blocs de scénario avec lesquels la chaîne répond ; ignorez cette étape si la chaîne dispose déjà d'un bot que vous pouvez modifier.
2. **Ajoutez une skill** et définissez son URL sur l'**URL de la skill** du connecteur, puis ajoutez un en-tête de requête personnalisé `X-Kakao-Bot-Secret` contenant votre **Secret du bot**. Kakao ne signe pas les requêtes de skill : cet en-tête est donc la seule preuve qu'un appel provient bien de votre bot.
3. **Faites pointer le bloc de repli vers la skill** afin que chaque question non gérée par vos scénarios parvienne à l'agent. Reliez un bloc de scénario nommé à la même skill si l'agent doit aussi y répondre.
4. **Activez l'option de rappel (callback)** pour ce bloc. Kakao abandonne une réponse de skill qui met plus de cinq secondes à arriver ; avec le callback activé, Make Agent Fast renvoie immédiatement une bulle d'attente, puis publie la réponse finale sur `userRequest.callbackUrl` dans la minute pendant laquelle cette URL à usage unique reste valide.
5. **Connectez la chaîne KakaoTalk** au bot, puis collez ce même identifiant de chaîne dans le champ **ID de la chaîne** du connecteur dans Make Agent Fast.
6. **Déployez le bot.** Les modifications d'Open Builder n'atteignent les visiteurs qu'après un déploiement, et chaque modification ultérieure d'une skill ou d'un bloc nécessite un nouveau déploiement.

Le reste de cette page détaille ces mêmes six étapes.

## Préparer les éléments Kakao [#préparer-les-éléments-kakao]

Créez ou sélectionnez l'application Kakao Developers, la chaîne KakaoTalk et le bot Kakao i Open Builder qui hébergeront l'intégration. Consultez la [documentation officielle d'Open Builder](https://i.kakao.com/docs/key-concepts-block#skill) de Kakao pour les skills et les blocs.

Rassemblez ou créez ces valeurs :

| Champ Make Agent Fast | Source                                        | Utilité                                                              |
| --------------------- | --------------------------------------------- | -------------------------------------------------------------------- |
| **ID de la chaîne**   | ID public/de recherche de la chaîne KakaoTalk | Associe le connecteur à la chaîne visée                              |
| **Clé d'API REST**    | Clés de l'application Kakao Developers        | Valide l'application Kakao                                           |
| **Secret du bot**     | Un secret aléatoire long que vous générez     | Authentifie les requêtes de skill entrantes via `X-Kakao-Bot-Secret` |

Le Secret du bot est obligatoire sur les environnements Make Agent Fast déployés, car les appels de skill Kakao ne fournissent aucune signature de plateforme. Générez une valeur unique à forte entropie et ne réutilisez pas la clé d'API REST comme secret.

## Enregistrer le connecteur [#enregistrer-le-connecteur]

Ouvrez la page **Canaux** de l'agent, choisissez **Chaîne KakaoTalk**, saisissez les trois valeurs, puis sélectionnez **Connecter**. Make Agent Fast valide la clé d'API REST lorsque les autorisations de Kakao le permettent et affiche l'**URL du webhook** propre au connecteur après l'enregistrement.

Make Agent Fast ne peut pas créer la skill Open Builder ni la rattacher à un bloc à votre place ; le reste du travail s'effectue dans la console de Kakao.

## Configurer la skill Open Builder [#configurer-la-skill-open-builder]

1. Dans Kakao i Open Builder, créez une skill pour le bot concerné.
2. Définissez l'URL de la skill sur l'**URL du webhook** copiée depuis le connecteur.
3. Ajoutez un en-tête de requête personnalisé nommé `X-Kakao-Bot-Secret` dont la valeur correspond exactement au **Secret du bot**.
4. Reliez la skill au bloc de repli ou au bloc de scénario qui doit invoquer l'agent.
5. Activez l'option de rappel (callback) de ce bloc afin que les réponses lentes respectent le délai de cinq secondes imposé par Kakao aux skills.
6. Enregistrez, puis déployez/publiez la configuration du bot en suivant le processus de Kakao.

L'en-tête n'est pas sensible à la casse selon les règles HTTP, mais la valeur du secret doit être exacte. Toute personne qui connaît l'URL du webhook sans connaître ce secret doit recevoir une réponse « non autorisé ».

## Tester les fonctionnalités [#tester-les-fonctionnalités]

Utilisez d'abord l'outil de test d'Open Builder, puis la chaîne KakaoTalk connectée. Envoyez une question textuelle réaliste en coréen ou dans une langue prise en charge, puis vérifiez la réponse en ligne, le **Dernier message** et le fil dans **Conversations**.

La carte du connecteur copie le corps de requête ci-dessous ; ce même corps fonctionne avec `curl` sur l'URL de la skill. Il ne contient aucun `callbackUrl`, la réponse revient donc en ligne — c'est le plus simple à vérifier en premier.

```json
{
  "intent": {
    "id": "5a56ec0cf65e53002d34e0f4",
    "name": "Fallback block"
  },
  "userRequest": {
    "timezone": "Asia/Seoul",
    "utterance": "What are your opening hours?",
    "lang": "kr",
    "user": {
      "id": "kakao-test-user",
      "type": "botUserKey",
      "properties": {
        "plusfriendUserKey": "kakao-test-user"
      }
    },
    "block": {
      "id": "5a56ec0cf65e53002d34e0f4",
      "name": "Fallback block"
    }
  },
  "bot": {
    "id": "5a56ec0cf65e53002d34e0f2",
    "name": "Your bot"
  },
  "action": {
    "id": "5a56ec0cf65e53002d34e0f6",
    "name": "Make Agent Fast skill",
    "params": {},
    "detailParams": {},
    "clientExtra": {}
  }
}
```

Une skill en bon état répond dans le délai de cinq secondes avec une seule sortie `simpleText` :

```json
{
  "version": "2.0",
  "template": {
    "outputs": [
      {
        "simpleText": {
          "text": "We are open 9:00–18:00 on weekdays."
        }
      }
    ]
  }
}
```

Une fois l'option de rappel du bloc activée, Open Builder ajoute `userRequest.callbackUrl` à la requête. Make Agent Fast répond alors d'abord avec une bulle d'attente, puis envoie en POST la réponse finale à cette URL à usage unique :

```json
{
  "version": "2.0",
  "useCallback": true,
  "data": {
    "text": "One moment — I am looking that up."
  }
}
```

Le contrat actuel de la skill est limité au texte. La réponse de l'agent est un seul `skillResponse` Kakao en version `2.0` avec une sortie `simpleText`, plafonnée sous la limite de texte de Kakao, renvoyée en ligne ou sur l'URL de rappel. La voix, les fichiers, les images et l'audio sortant distinct ne sont pas pris en charge.

## Renouveler ou déconnecter [#renouveler-ou-déconnecter]

Pour renouveler le Secret du bot, mettez à jour le connecteur et l'en-tête personnalisé d'Open Builder en une seule opération coordonnée, puis testez immédiatement. Toute divergence bloque l'ensemble des requêtes entrantes. Renouvelez la clé d'API REST dans Kakao Developers et dans Make Agent Fast avant de révoquer l'ancienne clé.

Désactiver ou supprimer le connecteur ne supprime ni la skill ni le bloc Open Builder. Supprimez ou détachez ces objets côté fournisseur lorsque vous désactivez définitivement l'intégration.

## Dépannage [#dépannage]

| Symptôme                                               | Solution                                                                                                             |
| ------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| Le connecteur exige un Secret du bot                   | Générez-en un ; les environnements déployés refusent un webhook Kakao non authentifié                                |
| Clé d'API REST rejetée                                 | Utilisez la clé d'API REST de l'application Kakao concernée et vérifiez les autorisations de sa chaîne               |
| Open Builder reçoit « non autorisé »                   | Ajoutez ou mettez à jour `X-Kakao-Bot-Secret` pour qu'il corresponde exactement à la valeur du connecteur            |
| L'outil de test affiche un repli au lieu d'une réponse | Vérifiez que le bloc invoque bien l'URL de skill enregistrée et consultez les journaux de requêtes/réponses de Kakao |
| Les requêtes expirent                                  | Activez l'option de rappel du bloc ; sans elle, Kakao accorde cinq secondes à la skill                               |
| La voix ou les images sont ignorées                    | C'est normal ; le connecteur actuel n'accepte que le texte                                                           |

N'exposez jamais la clé d'API REST ni le Secret du bot dans du code côté client ou dans une documentation publique.

---

# Messenger

Source: /fr/docs/connectors/messenger.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/connectors/overview&#x22;, label: &#x22;Tous les connecteurs&#x22;, icon: &#x22;connectors&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Boîte de réception&#x22;, icon: &#x22;message&#x22; },
{ label: &#x22;Messenger&#x22;, icon: &#x22;messenger&#x22; }
]"
/>

<TutorialVideo episode="ep09" start="31" />

## Préparer l'application Meta et la Page [#préparer-lapplication-meta-et-la-page]

Suivez le [guide de démarrage officiel de la plateforme Messenger](https://developers.facebook.com/docs/messenger-platform/get-started) de Meta. Ajoutez Messenger à une application Meta, connectez la Page Facebook qui doit recevoir les messages et assurez-vous que votre compte peut administrer ces deux éléments.

Récupérez les valeurs depuis la même application et la même Page :

| Champ Make Agent Fast        | Valeur du fournisseur                                     | Utilité                                          |
| ---------------------------- | --------------------------------------------------------- | ------------------------------------------------ |
| **Jeton d'accès de la Page** | Jeton émis pour la Page sélectionnée                      | Lit l'identité de la Page et envoie les réponses |
| **Secret de l'application**  | Secret hexadécimal de 32 caractères de l'application Meta | Vérifie les requêtes webhook entrantes signées   |

N'utilisez pas de jeton d'accès utilisateur ni de jeton appartenant à une autre Page. Le mode de développement et l'état de la validation (review) de l'application Meta déterminent quelles personnes peuvent utiliser l'intégration.

## Enregistrer et valider les identifiants [#enregistrer-et-valider-les-identifiants]

Ouvrez la page **Canaux** de l'agent, sélectionnez **Messenger**, saisissez le jeton d'accès de la Page et le secret de l'application, puis sélectionnez **Connecter**.

Make Agent Fast appelle la Graph API avec `appsecret_proof`, récupère l'ID et le nom de la Page, puis lie les événements entrants à cette Page précise. La carte du connecteur affiche ensuite son **URL du webhook** et son **Jeton de vérification**.

## Configurer le webhook de la Page [#configurer-le-webhook-de-la-page]

Dans la même application Meta :

1. Ouvrez les paramètres du webhook Messenger.
2. Collez l'**URL du webhook** et le **Jeton de vérification** du connecteur.
3. Terminez le défi de vérification.
4. Sélectionnez l'abonnement aux événements de message requis par votre workflow Messenger.
5. Abonnez la Page Facebook visée à l'application.
6. Vérifiez que l'abonnement de la Page et le mode de l'application autorisent votre utilisateur de test.

Le jeton de vérification ne sert que pour le défi initial. Les événements en production doivent porter une signature correspondant au secret de l'application. Make Agent Fast rejette également les événements adressés à une autre Page, même s'ils proviennent de la même application Meta.

## Tester les fonctionnalités [#tester-les-fonctionnalités]

Envoyez un message normal à la Page depuis un compte de test autorisé et non administrateur, puis vérifiez la réponse ainsi que le fil dans **Conversations**. Testez ensuite une pièce jointe audio si les messages vocaux entrants comptent pour votre workflow.

Le texte et les fichiers audio entrants pris en charge sont traités. Dans le connecteur Messenger actuel, les réponses sont uniquement textuelles, même lorsque le message d'origine était vocal. Les accusés de livraison et de lecture, les échos des propres messages de la Page, les images et les autres pièces jointes non prises en charge sont ignorés.

## Prêt pour la production [#prêt-pour-la-production]

Réalisez les étapes exigées par Meta pour votre audience : autorisations, validation de l'application (app review), vérification de l'entreprise, URL de politique de confidentialité et publication de la Page. Un test réussi en mode développement avec un compte ayant un rôle sur l'application ne prouve pas que le public peut écrire à l'intégration de la Page.

Documentez l'application Meta propriétaire et l'ID de la Page pour les opérateurs. Un jeton de Page peut cesser de fonctionner lorsque son propriétaire, ses autorisations, son association à une entreprise ou la politique du fournisseur changent.

## Effectuer une rotation ou déconnecter [#effectuer-une-rotation-ou-déconnecter]

Générez le nouveau jeton de Page, mettez à jour le connecteur, testez avec un utilisateur autorisé, puis invalidez l'ancien jeton. Mettez à jour Make Agent Fast immédiatement après la rotation du secret de l'application.

Désactiver ou supprimer le connecteur ne désabonne pas la Page dans Meta. Lorsque vous mettez définitivement l'intégration hors service, supprimez l'abonnement de la Page ainsi que les identifiants du fournisseur devenus inutiles.

## Dépannage [#dépannage]

| Symptôme                                                      | Solution                                                                                                                                         |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| Jeton rejeté                                                  | Vérifiez qu'il s'agit d'un jeton de Page pour la bonne Page et que le secret de l'application appartient à la même application                   |
| La vérification du webhook échoue                             | Copiez exactement l'URL et le jeton de vérification actuels ; utilisez un HTTPS public                                                           |
| La vérification fonctionne mais les messages n'arrivent pas   | Abonnez la Page et l'événement de message, puis vérifiez le mode de l'application, le rôle de l'utilisateur et les journaux de livraison de Meta |
| Les requêtes sont non autorisées                              | Corrigez le secret de l'application ; les requêtes POST signées n'utilisent pas le jeton de vérification                                         |
| Un message entrant apparaît mais aucune réponse n'est envoyée | Vérifiez la validité du jeton de Page, les autorisations de messagerie, l'erreur d'envoi du fournisseur et l'état du connecteur                  |
| Un message vocal reçoit une réponse textuelle                 | Comportement attendu ; les réponses vocales sortantes ne sont pas prises en charge actuellement sur Messenger                                    |

Les identifiants du fournisseur doivent uniquement être saisis dans le formulaire du connecteur authentifié ou transmis via un appel d'API côté serveur de confiance.

---

# Présentation des connecteurs

Source: /fr/docs/connectors/overview.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/connectors/telegram&#x22;, label: &#x22;Telegram&#x22;, icon: &#x22;telegram&#x22; },
{ href: &#x22;/fr/docs/connectors/whatsapp&#x22;, label: &#x22;WhatsApp&#x22;, icon: &#x22;whatsapp&#x22; },
{ href: &#x22;/fr/docs/connectors/messenger&#x22;, label: &#x22;Messenger&#x22;, icon: &#x22;messenger&#x22; },
{ href: &#x22;/fr/docs/connectors/instagram&#x22;, label: &#x22;Instagram&#x22;, icon: &#x22;instagram&#x22; },
{ href: &#x22;/fr/docs/connectors/discord&#x22;, label: &#x22;Discord&#x22;, icon: &#x22;discord&#x22; },
{ href: &#x22;/fr/docs/connectors/kakao&#x22;, label: &#x22;KakaoTalk&#x22;, icon: &#x22;kakao&#x22; }
]"
/>

Les connecteurs reçoivent les événements d'une plateforme de messagerie externe, normalisent le texte ou l'audio pris en charge, exécutent le même agent de site et renvoient une réponse adaptée au canal. Chaque utilisateur externe dispose d'un historique de conversation propre au canal, visible dans **Conversations**.

La connexion d'un **nouveau** canal nécessite l'offre Operate ou Scale. Les connexions existantes continuent de fonctionner avec l'offre Launch.

<TutorialVideo episode="ep09" start="15" />

## Matrice des fonctionnalités [#matrice-des-fonctionnalités]

| Canal     | Texte entrant   | Voix entrante | Texte sortant             | Voix sortante | Configuration chez le fournisseur après l'enregistrement                                          |
| --------- | --------------- | ------------- | ------------------------- | ------------- | ------------------------------------------------------------------------------------------------- |
| Telegram  | Oui             | Oui           | Oui                       | Facultatif    | Webhook enregistré automatiquement                                                                |
| WhatsApp  | Oui             | Oui           | Oui                       | Facultatif    | Ajoutez le webhook Meta et l'abonnement `messages`                                                |
| Messenger | Oui             | Oui           | Oui                       | Non           | Ajoutez le webhook Meta et abonnez la Page                                                        |
| Instagram | Oui             | Oui           | Oui                       | Non           | Ajoutez le webhook Meta Instagram et abonnez `messages`                                           |
| Discord   | Question `/ask` | Non           | Réponse `/ask`            | Non           | Collez le point de terminaison des interactions ; l'enregistrement de la commande est automatique |
| KakaoTalk | Oui             | Non           | Réponse de skill en ligne | Non           | Ajoutez l'URL du skill, l'en-tête et le bloc dans Open Builder                                    |

« Voix entrante » signifie qu'un message vocal ou audio pris en charge est téléchargé puis transcrit. « Voix sortante » nécessite un fournisseur de synthèse vocale opérationnel et l'option **Répondre par message vocal** du connecteur. Les pièces jointes non prises en charge, telles que les images et les localisations, sont ignorées et ne sont pas interprétées comme des instructions pour l'agent.

## Avant de connecter [#avant-de-connecter]

1. Testez l'agent concerné dans le tableau de bord. Un connecteur en brouillon peut déjà répondre.
2. Vous n'avez pas besoin de clé de modèle : la plateforme fournit les modèles. Les clés de fournisseur sont facultatives et réservées à l'offre Scale ; consultez [Clés de fournisseur](/fr/docs/account/provider-keys).
3. Créez une application, un bot, un numéro ou un canal dédié chez le fournisseur externe. Ne réutilisez pas un identifiant appartenant à une intégration de production sans rapport.
4. Vérifiez que votre déploiement dispose d'une URL de base de connecteur publique en HTTPS. Les webhooks des fournisseurs ne peuvent pas être livrés à `localhost` sans tunnel de développement sécurisé.
5. Ouvrez la page **Canaux** de l'agent et choisissez le canal.

Lors de l'enregistrement, Make Agent Fast appelle le fournisseur pour valider l'identifiant soumis. Le libellé « connecté » signifie que la validation de l'identifiant et tout provisionnement automatique ont abouti ; il ne prouve pas qu'une étape manuelle dans la console Meta, Discord ou Kakao a été réalisée.

## Gestion des identifiants [#gestion-des-identifiants]

Les formulaires de connecteur n'acceptent les identifiants du fournisseur que depuis le tableau de bord authentifié ou l'API publique côté serveur. Les secrets sont chiffrés au repos et ne sont jamais renvoyés dans les réponses de liste des connecteurs. Traitez les valeurs suivantes comme des mots de passe :

* Jeton de bot Telegram
* Jetons d'accès Meta et secret de l'application
* Jeton de bot Discord
* Clé d'API REST Kakao et secret du bot

Ne les placez pas dans du JavaScript côté navigateur, des captures d'écran, des tickets de support ou un dépôt de code source. L'URL du webhook et le jeton de vérification Meta sont des valeurs de configuration destinées à être copiées dans la console du fournisseur correspondant ; elles ne remplacent pas les identifiants du fournisseur.

## Se connecter via l'API [#se-connecter-via-lapi]

Utilisez une clé d'API MAF conservée côté serveur avec le scope `connectors:write`. L'objet `credentials` propre à chaque canal est en écriture seule. La réponse omet les secrets en clair et inclut l'URL du webhook nécessaire à la configuration manuelle chez le fournisseur.

```bash
curl -X POST "https://makeagent.fast/api/v1/sites/$SITE_ID/connectors" \
  -H "Authorization: Bearer $MAF_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: connector-telegram-v1" \
  -d '{
    "channel": "telegram",
    "credentials": { "bot_token": "'$TELEGRAM_BOT_TOKEN'" },
    "reply_with_voice": false
  }'
```

`reply_with_voice` et le champ facultatif `display_label` sont des champs de premier niveau, et non des éléments d'un objet `config`. Enregistrer à nouveau le même bot ou le même compte met à jour son identifiant et ses paramètres tout en conservant son jeton de routage. Pour Telegram et Instagram, un bot ou un compte différent ajoute une nouvelle connexion (jusqu'à cinq par agent) ; sur les autres canaux, l'enregistrement remplace la connexion existante. Consultez [Authentification de l'API](/fr/docs/api/authentication), [Scopes et erreurs](/fr/docs/api/scopes-errors) et la [référence de l'API](/fr/docs/api/reference) pour les règles d'intégration en production.

## Tester et surveiller [#tester-et-surveiller]

Utilisez un utilisateur de test du fournisseur et une question réaliste qui dépend des connaissances de l'agent. Vérifiez chacun des points suivants :

* Le fournisseur accepte ou vérifie le point de terminaison du webhook.
* Un message parvient à l'agent et reçoit la réponse attendue.
* **Dernier message** change sur la carte du connecteur.
* Le fil apparaît dans **Conversations** avec le bon canal.
* Toute restriction du fournisseur liée à la validation ou au mode développement est bien comprise avant le lancement public.
* La voix est testée séparément du texte lorsque le canal la prend en charge.

La carte du connecteur affiche la dernière erreur du fournisseur ou de livraison. Les tableaux de bord des fournisseurs conservent également des journaux de livraison ; comparez les horodatages et les identifiants d'événements lorsqu'un seul côté signale la requête.

## Désactiver, renouveler ou supprimer [#désactiver-renouveler-ou-supprimer]

**Désactiver** interrompt le traitement tout en conservant l'enregistrement du connecteur. Le webhook Telegram reste enregistré tant que la connexion est désactivée (Make Agent Fast n'appelle pas `deleteWebhook`) et les messages entrants sont ignorés ; la réactivation enregistre à nouveau le webhook. Les abonnements du fournisseur configurés dans la console restent en place et doivent aussi être suspendus côté fournisseur si nécessaire. **Supprimer** supprime le connecteur Make Agent Fast et tente, dans la mesure du possible, de démanteler la configuration chez le fournisseur, mais ne supprime pas l'application externe, ne révoque pas son identifiant et n'efface pas l'historique de conversation existant.

Pour un renouvellement, créez le nouveau jeton chez le fournisseur, mettez à jour le connecteur, testez-le, puis révoquez l'ancien jeton. Si un identifiant a été exposé, révoquez-le d'abord chez le fournisseur et traitez la période concernée comme un incident de sécurité.

## Problèmes courants [#problèmes-courants]

| Symptôme                                            | À vérifier                                                                                                                                                                    |
| --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Les identifiants ne sont pas validés                | Application/bot corrects, type de jeton, expiration, permission requise du fournisseur et caractères copiés                                                                   |
| La vérification du webhook échoue                   | URL HTTPS publique, jeton de vérification exact, bon produit du fournisseur et secret de signature des requêtes                                                               |
| La vérification réussit mais aucun message n'arrive | Abonnement aux événements, association de la Page/du numéro/du canal, mode de l'application du fournisseur et état d'activation du connecteur                                 |
| Le texte fonctionne mais pas la voix                | Prise en charge par le canal, clé de synthèse/transcription vocale, audio pris en charge, autorisation d'accès aux médias et expiration du téléchargement chez le fournisseur |
| Les réponses s'arrêtent après le renouvellement     | Nouvel identifiant enregistré, ancien identifiant révoqué uniquement après les tests et abonnement manuel du fournisseur pointant toujours vers ce webhook                    |

Poursuivez avec le guide du canal concerné pour connaître les champs exacts du fournisseur et la séquence à suivre dans sa console.

---

# Telegram

Source: /fr/docs/connectors/telegram.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/connectors/overview&#x22;, label: &#x22;Tous les connecteurs&#x22;, icon: &#x22;connectors&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Boîte de réception&#x22;, icon: &#x22;message&#x22; },
{ label: &#x22;Telegram&#x22;, icon: &#x22;telegram&#x22; }
]"
/>

<TutorialVideo episode="ep03" />

## Configuration rapide [#configuration-rapide]

Si l'option **Créer avec un QR code** est disponible sur le connecteur Telegram, sélectionnez-la, scannez le QR code ou choisissez **Ouvrir Telegram**, puis appuyez sur **Créer le bot** dans le bot de configuration. Revenez dans Make Agent Fast, vérifiez le nom d'utilisateur du bot, puis sélectionnez **Connecter ce bot**. Aucune copie de token n'est nécessaire. La configuration expire au bout de 15 minutes ; vous pouvez l'annuler et la relancer.

Si la configuration rapide n'est pas disponible, utilisez **Se connecter avec un token de bot** ci-dessous. Les deux méthodes appliquent les mêmes vérifications de connexion et la même confirmation de remplacement.

Le formulaire de création suggère le nom d'affichage de votre agent et un nom d'utilisateur au format `maf_<agent>_<random>_bot`. Les deux sont modifiables ; la partie aléatoire réduit les collisions de noms, mais c'est Telegram qui effectue la vérification finale de disponibilité. Les bots existants ne sont pas renommés.

Une fois le bot créé, le bot de configuration envoie un bouton **Connecter ce bot** qui ouvre l'écran d'examen de connexion authentifié de votre agent. La création du bot ne suffit pas à le connecter. Une fois la confirmation réussie, **Ouvrir le bot** vous mène à la conversation pour effectuer vos tests. `/start` ou `/help` rétablit une configuration active ou affiche les boutons du tableau de bord et du guide.

## Créer et préparer un bot manuellement [#créer-et-préparer-un-bot-manuellement]

Suivez l'[Introduction to Bots](https://core.telegram.org/bots) officielle de Telegram et le [guide BotFather](https://core.telegram.org/bots/features#botfather) :

1. Ouvrez le compte vérifié **@BotFather** dans Telegram.
2. Lancez `/newbot`, choisissez un nom d'affichage, puis un nom d'utilisateur unique se terminant par `bot`.
3. Copiez le token du bot. Toute personne possédant ce token contrôle le bot.
4. Si vous le souhaitez, configurez la photo, la description, le texte « À propos » et l'aide localisée des commandes dans BotFather avant le lancement.

Le token sert à l'API Telegram Bot ; ce n'est ni un code de connexion Telegram, ni un API ID, ni un API hash.

## Se connecter dans Make Agent Fast [#se-connecter-dans-make-agent-fast]

Ouvrez la page **Canaux** de l'agent, choisissez **Telegram**, collez le **Token du bot**, indiquez si les réponses compatibles doivent aussi être énoncées à voix haute, puis sélectionnez **Connecter**.

Make Agent Fast appelle `getMe` de Telegram pour valider le token et afficher le nom d'utilisateur du bot. Il appelle ensuite `setWebhook` avec l'URL HTTPS publique du connecteur, un token de vérification secret, et `message`, `callback_query` et `my_chat_member` comme types de mises à jour acceptés. Les mises à jour en attente existantes ne sont pas supprimées.

Aucune étape manuelle de webhook n'est normalement requise. Arrêtez tout service de polling avant de vous connecter. Si le bot dispose d'un autre récepteur de webhook, examinez et confirmez son remplacement ; Make Agent Fast ne le reprend jamais silencieusement. Un agent peut répondre sur jusqu'à cinq bots Telegram simultanément ; chaque bot constitue sa propre connexion. Enregistrer un autre bot ajoute une nouvelle connexion au lieu de remplacer la connexion actuelle. Un bot déjà rattaché à un autre agent doit d'abord y être déconnecté.

## Tester la conversation [#tester-la-conversation]

1. Ouvrez le lien `t.me` du bot depuis un compte Telegram qui n'est pas celui du propriétaire.
2. Sélectionnez **Démarrer** ; les bots ne peuvent pas initier une conversation avec un utilisateur.
3. Envoyez une question textuelle dont la réponse figure dans vos sources.
4. Envoyez un message vocal si la voix est activée.
5. Vérifiez que les réponses arrivent, que **Dernier message** change et que le fil apparaît dans **Conversations**.

Les messages privés sont publics par défaut : les visiteurs n'ont pas besoin de l'approbation du propriétaire. Les réponses dans les groupes sont désactivées tant que le propriétaire n'active pas **Répondre dans les groupes lorsque le bot est mentionné ou qu'on lui répond**. Le mode confidentialité de Telegram (Privacy Mode) et les autorisations du groupe continuent de s'appliquer. Testez d'abord les messages directs.

## Fonctionnement de la voix [#fonctionnement-de-la-voix]

Telegram prend en charge la voix entrante et la voix sortante dans ce connecteur. La voix entrante est téléchargée puis transcrite avant le tour de l'agent. Lorsque **Répondre par la voix** est activé et qu'un fournisseur de synthèse vocale est disponible, Make Agent Fast envoie une réponse vocale/audio en plus du texte. Si la transcription ou la synthèse vocale échoue, demandez à l'utilisateur de réessayer par écrit et consultez l'erreur du connecteur.

## Renouveler, désactiver ou supprimer [#renouveler-désactiver-ou-supprimer]

Si le token est exposé, générez-en un nouveau ou révoquez-le immédiatement dans BotFather, mettez à jour le connecteur avec le nouveau token, puis testez à nouveau. La mise à jour des identifiants d'un même bot conserve ses paramètres et son statut de pause. Le remplacer par un autre bot nécessite une confirmation et conserve l'historique du bot précédent séparé.

Désactiver un bot arrête les réponses en local ; le supprimer archive la connexion et conserve son historique. Aucune de ces actions ne supprime le bot Telegram ni n'appelle `deleteWebhook`, ce qui pourrait perturber un récepteur plus récent. Les connexions archivées ignorent les messages entrants. Les bots créés via la configuration rapide peuvent actualiser leurs identifiants après des événements du cycle de vie côté gestionnaire, mais un bot en pause reste en pause et un changement de propriétaire désactive la connexion en vue d'un examen.

## Dépannage [#dépannage]

| Symptôme                                                    | Solution                                                                                                                                                                |
| ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Token rejeté à l'enregistrement                             | Copiez le token actuel depuis BotFather ; supprimez les espaces et assurez-vous qu'il appartient bien à ce bot                                                          |
| Les messages arrivent sur un ancien service                 | Arrêtez le polling sur ce service, reconnectez-vous ici et confirmez explicitement tout remplacement de récepteur                                                       |
| Les messages directs fonctionnent mais pas ceux des groupes | Activez les réponses dans les groupes, mentionnez le bot ou répondez-lui, et vérifiez le mode confidentialité de Telegram (Privacy Mode) et les autorisations du groupe |
| Le bot n'écrit pas en premier à un nouvel utilisateur       | Comportement normal de Telegram ; demandez à l'utilisateur d'ouvrir le bot et de sélectionner **Démarrer**                                                              |
| Le texte fonctionne mais pas la voix                        | Vérifiez les clés du modèle, de transcription et de synthèse vocale, puis réessayez avec un message vocal Telegram pris en charge                                       |

Ne collez jamais un token actif dans de la documentation, du code source, des outils d'analyse ou une capture d'écran destinée au support.

---

# WhatsApp

Source: /fr/docs/connectors/whatsapp.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/connectors/overview&#x22;, label: &#x22;Tous les connecteurs&#x22;, icon: &#x22;connectors&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Boîte de réception&#x22;, icon: &#x22;message&#x22; },
{ label: &#x22;WhatsApp&#x22;, icon: &#x22;whatsapp&#x22; }
]"
/>

<TutorialVideo episode="ep04" />

## Préparer l'application Meta et le numéro [#préparer-lapplication-meta-et-le-numéro]

Suivez le [guide de démarrage de l'API WhatsApp Cloud](https://developers.facebook.com/docs/whatsapp/cloud-api/get-started) officiel de Meta pour créer ou sélectionner une application Meta, ajouter le produit WhatsApp, puis associer un compte WhatsApp Business et un numéro de téléphone.

Récupérez ces trois valeurs à partir de la même application et du même numéro :

| Champ Make Agent Fast | Valeur du fournisseur                                          | Remarques                                                                                                                           |
| --------------------- | -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| **Phone number ID**   | Identifiant numérique du numéro de téléphone (Phone Number ID) | Il ne s'agit ni du numéro de téléphone visible commençant par `+`, ni de l'identifiant WABA                                         |
| **Access token**      | Jeton d'accès de l'API Cloud                                   | Les jetons temporaires du tableau de bord expirent ; utilisez un jeton d'utilisateur système de longue durée adapté à la production |
| **App secret**        | Clé secrète de l'application Meta                              | Une clé secrète hexadécimale de 32 caractères, utilisée pour vérifier la signature des webhooks                                     |

N'accordez que les autorisations nécessaires au numéro et au flux de messagerie. Séparez les ressources de développement/test du numéro de production.

## Enregistrer et valider les identifiants [#enregistrer-et-valider-les-identifiants]

Ouvrez la page **Canaux** de l'agent, sélectionnez **WhatsApp**, saisissez les trois valeurs, choisissez **Répondre par la voix** si nécessaire, puis sélectionnez **Connecter**.

Make Agent Fast valide le numéro via l'API Graph à l'aide du jeton d'accès et de `appsecret_proof` ; cela permet de détecter un numéro, un jeton ou une clé secrète d'application incorrects avant le début du trafic webhook. La carte du connecteur affiche alors une **URL du webhook** et un **Jeton de vérification** uniques.

## Configurer le webhook Meta [#configurer-le-webhook-meta]

Dans la même application Meta :

1. Ouvrez la configuration du webhook WhatsApp.
2. Collez l'**URL du webhook** du connecteur comme URL de rappel.
3. Collez le **Jeton de vérification** du connecteur à l'identique ; il est sensible à la casse.
4. Terminez la vérification.
5. Abonnez le compte WhatsApp Business ou le numéro au champ de webhook `messages`.
6. Vérifiez que l'application et les ressources de l'entreprise sont accessibles aux utilisateurs de test ou de production concernés.

Le jeton de vérification prouve que vous êtes propriétaire lors de la requête GET de vérification. Les requêtes POST en cours d'exécution sont authentifiées séparément par la signature de la clé secrète de l'application Meta ; ne substituez pas l'un à l'autre.

## Tester le texte et la voix [#tester-le-texte-et-la-voix]

Envoyez d'abord un message depuis un numéro de test autorisé. En mode développement Meta, les utilisateurs non enregistrés peuvent ne pas pouvoir joindre l'application. Vérifiez le fil et le canal dans **Conversations** et surveillez **Dernier message** sur la carte du connecteur.

Les messages entrants texte et vocaux sont pris en charge. Lorsque **Répondre par la voix** est activé et que la synthèse vocale est configurée, Make Agent Fast téléverse l'audio généré via l'API Cloud et l'envoie en complément de la réponse textuelle. Les images, les localisations, les contacts et les autres types de messages non pris en charge sont ignorés.

## Prêt pour la production [#prêt-pour-la-production]

Avant de communiquer le numéro, effectuez la vérification de l'entreprise auprès de Meta, la révision de l'application, la validation du nom d'affichage, les modèles de messages et les étapes liées à la politique de messagerie requises pour votre cas d'usage. Ces exigences sont contrôlées par Meta et peuvent évoluer indépendamment de Make Agent Fast.

Utilisez un identifiant de production avec un responsable clairement désigné et une procédure d'expiration/rotation. Notez quelle application Meta, quel utilisateur système, quel WABA et quel Phone Number ID correspondent à ce connecteur afin qu'un opérateur puisse effectuer la rotation sans tâtonner.

## Effectuer la rotation ou déconnecter [#effectuer-la-rotation-ou-déconnecter]

Créez un jeton de remplacement avec les mêmes accès aux ressources, mettez à jour le connecteur, envoyez un message de test, et ne révoquez l'ancien jeton qu'ensuite. Si la clé secrète de l'application change, mettez-la à jour immédiatement dans Make Agent Fast, sinon tous les webhooks entrants signés échoueront.

Désactiver ou supprimer le connecteur ne désabonne pas et ne supprime pas la configuration du webhook Meta. Supprimez également l'abonnement côté fournisseur lorsque vous mettez définitivement le numéro hors service.

## Dépannage [#dépannage]

| Symptôme                                            | Solution                                                                                                                                                              |
| --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Identifiants rejetés                                | Vérifiez que le jeton peut lire le Phone Number ID exact et que la clé secrète provient de la même application                                                        |
| Meta ne parvient pas à vérifier l'URL de rappel     | Utilisez l'URL HTTPS copiée et le jeton de vérification exact ; assurez-vous que le connecteur existe toujours                                                        |
| La vérification réussit mais aucun message n'arrive | Abonnez-vous à `messages`, vérifiez l'association WABA/numéro, le mode de l'application, l'accès des utilisateurs de test et les journaux de livraison du fournisseur |
| Les webhooks renvoient une erreur d'autorisation    | Saisissez à nouveau la bonne clé secrète de l'application ; les signatures POST de Meta n'utilisent pas le jeton de vérification                                      |
| Les réponses sortantes échouent                     | Vérifiez l'expiration du jeton, les autorisations du numéro, la politique/la fenêtre de messagerie du destinataire et les erreurs de l'API Graph                      |
| Le texte fonctionne mais pas l'audio                | Vérifiez les clés des fournisseurs de transcription/synthèse vocale et l'accès du jeton au téléversement/téléchargement de médias                                     |

N'exposez jamais le jeton d'accès ni la clé secrète de l'application dans du code côté navigateur. Utilisez l'API publique uniquement depuis un serveur de confiance lorsque vous automatisez la création de connecteurs.

---

# Astro

Source: /fr/docs/embed/astro.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Astro&#x22;, icon: &#x22;astro&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Préparer l'origine de déploiement [#préparer-lorigine-de-déploiement]

Activez **Afficher sur mon site web** pour l'agent Make Agent Fast (page de l'agent → **Mettre en ligne** → **Widget du site web**), puis ajoutez les origines exactes de développement, de prévisualisation et de production Astro sous **Adresses de site web autorisées**. Ce qui compte, c'est le schéma, le nom d'hôte et le port finaux affichés dans le navigateur, et non l'hôte de build ni l'URL du dépôt.

## Ajouter à un layout partagé [#ajouter-à-un-layout-partagé]

Placez le loader externe standard juste avant `</body>` dans le layout Astro qui doit gérer le lanceur.

```astro
---
// src/layouts/BaseLayout.astro
---

<html lang="en">
  <body>
    <slot />

    <script
      is:inline
      src="https://makeagent.fast/embed.js?v=20261022-open"
      data-agent="YOUR_SITE_SLUG"
      data-position="right"
      data-label="Ask us"
      async
    ></script>
  </body>
</html>
```

`is:inline` indique à Astro de conserver la balise de script externe et ses attributs `data-*` au lieu de les regrouper ou de les transformer. Le loader reste public et indépendant du framework ; ne l'importez pas dans un module serveur.

## Limiter à certaines pages [#limiter-à-certaines-pages]

Utilisez un layout imbriqué ou incluez la balise uniquement dans certaines pages `.astro`. Évitez de placer la même balise à la fois dans un layout de base et dans une page. Le loader ignore une racine en double avec le même slug, mais le HTML dupliqué rend la navigation et le démontage difficiles à prévoir.

Si les transitions de vue côté client d'Astro sont activées, testez les chargements directs de page ainsi que la navigation interne. Pour un agent présent sur tout le site, un layout partagé persistant est préférable. Pour un comportement propre à certaines routes, supprimez à la fois le script et `maf-embed-root-YOUR_SITE_SLUG` lorsque vous quittez la route, avant d'insérer ultérieurement un nouveau script.

## Configurer la CSP et le consentement [#configurer-la-csp-et-le-consentement]

Les en-têtes de l'hébergement statique continuent de contrôler le navigateur. Autorisez `https://makeagent.fast` dans `script-src`, `frame-src` et la politique de connexion concernée. Si un gestionnaire de consentement bloque le script, chargez la balise uniquement après obtention du consentement requis, plutôt que d'affaiblir la CSP ou de contourner le consentement.

## Vérifier le résultat du build [#vérifier-le-résultat-du-build]

1. Lancez le build de production d'Astro et inspectez le HTML généré pour vérifier que la balise `data-agent` est conservée.
2. Ouvrez la page déployée dans une fenêtre privée.
3. Vérifiez qu'il n'y a qu'une seule racine d'intégration et que les requêtes du loader et de l'iframe réussissent.
4. Naviguez entre les routes Astro et vérifiez que la persistance correspond à ce que vous attendez.
5. Envoyez un vrai message et testez le comportement sur mobile ainsi que le microphone.

## Dépannage [#dépannage]

| Symptôme                                                        | Solution                                                                    |
| --------------------------------------------------------------- | --------------------------------------------------------------------------- |
| Le HTML généré omet ou modifie les attributs                    | Ajoutez `is:inline` au script externe                                       |
| Deux balises de script sont générées                            | Gardez l'installation dans un seul layout ou une seule page responsable     |
| La navigation côté client diffère du chargement direct          | Testez les transitions de vue et choisissez un layout partagé persistant    |
| Fonctionne en développement mais pas sur l'hébergement statique | Ajoutez l'origine exacte de production et les en-têtes CSP de l'hébergement |
| La voix ne fonctionne pas                                       | Configurez HTTPS, l'autorisation du navigateur et la Permissions Policy     |

Aucun adaptateur npm pour Astro n'est actuellement publié ; utilisez le loader hébergé présenté ici.

---

# Cafe24

Source: /fr/docs/embed/cafe24.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: &#x22;Présentation de l’intégration&#x22;, icon: &#x22;embed&#x22; },
{ label: &#x22;Cafe24&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

Cafe24 (카페24) est une plateforme de commerce coréenne dont le design de boutique se modifie en HTML. Installez le lanceur dans la mise en page partagée du design que vous utilisez. Il n'existe actuellement aucune application Make Agent Fast dans l'App Store de Cafe24. Les noms de menus indiqués ici sont valables en date de 2026-09 ; si un libellé a changé de place, cherchez le paramètre en fonction de sa fonction plutôt que de son chemin exact.

## Ajouter le loader [#ajouter-le-loader]

1. Dans le tableau de bord Make Agent Fast, ouvrez **Mettre en ligne** → **Widget de site web** sur la page de l'agent, activez **Afficher sur mon site web**, puis ajoutez à **Adresses de site web autorisées** toutes les origines de votre boutique : l'adresse de boutique en `cafe24.com` et votre domaine personnalisé, ainsi que l'adresse mobile si elle est différente.
2. Ouvrez la gestion du design et lancez la modification HTML du design actuellement en ligne. Dupliquez ou sauvegardez d'abord le design : vous modifiez le code source de la boutique.
3. Dans le fichier de mise en page partagé que toutes les pages incluent, collez l'extrait généré juste avant la balise fermante `</body>`.
4. Enregistrez, appliquez le design à la boutique, puis recommencez pour le design mobile si votre boutique gère séparément les designs PC et mobile.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Si vous ne trouvez pas le fichier de mise en page, collez plutôt l'extrait dans le bloc de pied de page de votre thème : tout module affiché sur chaque page convient, à condition qu'il ne soit inclus qu'une seule fois.

## Vérifier [#vérifier]

1. Ouvrez la boutique dans une fenêtre de navigation privée, à la fois sur l'adresse PC et sur l'adresse mobile.
2. Vérifiez que l'origine affichée dans la barre d'adresse est bien celle que vous avez autorisée, y compris `www` si le domaine redirige vers cette version.
3. Vérifiez que `embed.js` renvoie `200` dans le panneau Réseau et qu'un seul élément `data-maf-embed="YOUR_SITE_SLUG"` existe.
4. Posez une question réaliste et vérifiez que le message apparaît dans **Conversations**.

## Dépannage [#dépannage]

| Symptôme                                                       | Cause probable                                              | Solution                                                                               |
| -------------------------------------------------------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------------------- |
| Fonctionne sur PC mais pas sur mobile                          | Le design mobile possède son propre fichier de mise en page | Ajoutez également l'extrait au design mobile                                           |
| Le lanceur a disparu après une modification du design          | Un design ne contenant pas l'extrait a été appliqué         | Ajoutez-le de nouveau à la mise en page du design actuellement utilisé par la boutique |
| Le lanceur recouvre le panier ou une barre fixe en bas de page | Deux éléments fixes occupent le même coin                   | Changez le coin du lanceur avec `data-position`                                        |

Ne placez jamais de clé API, de numéro de commande ni de données client dans un attribut `data-*`. [Sécurité et CSP](/fr/docs/embed/security) explique comment autoriser vos adresses et configurer la Content Security Policy pour les boutiques qui en définissent une.

---

# Framer

Source: /fr/docs/embed/framer.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l’intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Framer&#x22;, icon: &#x22;framer&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Disponibilité du composant de code [#disponibilité-du-composant-de-code]

Copiez `integrations/framer/MakeAgentFast.tsx` dans un composant de code Framer, puis choisissez l'agent publié. Le code source propose des commandes pour l'URL de la plateforme, la position et le libellé. Il s'agit d'un code source à copier manuellement, et non d'un composant publié sur le Framer Marketplace. Une URL de fiche n'apparaîtra ici qu'après la publication et la vérification par un propriétaire autorisé.

## Code personnalisé [#code-personnalisé]

Ajoutez le chargeur standard dans **Paramètres du site → Code personnalisé**, à la fin du body.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Publiez votre site avant de tester. Le canevas et l'hôte d'aperçu de Framer peuvent utiliser des origines différentes de celle du nom d'hôte publié en production.

---

# Ghost

Source: /fr/docs/embed/ghost.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: &#x22;Présentation de l’intégration&#x22;, icon: &#x22;embed&#x22; },
{ label: &#x22;Ghost&#x22;, icon: &#x22;ghost&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

Ouvrez **Settings → Code injection** (**Paramètres → Injection de code**) et ajoutez le script dans le pied de page du site.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

N'utilisez l'injection de code au niveau d'un article que si l'agent doit apparaître uniquement sur certains articles. Si vous modifiez plutôt un thème, placez le chargeur dans `default.hbs` avant `</body>` et revérifiez-le après les mises à jour du thème.

Ajoutez l'origine publique de la publication à la liste d'autorisation et videz tout cache en périphérie avant de tester un slug modifié.

---

# HTML et JavaScript

Source: /fr/docs/embed/html.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;HTML&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Préparer le site [#préparer-le-site]

Sur la page **Agent** de l'agent, ouvrez **Mettre en ligne** → **Widget de site web**, activez **Afficher sur mon site web**, puis ajoutez l'origine finale de la page hôte sous **Adresses de site web autorisées**. Ajoutez séparément les environnements de développement et de production : `http://localhost:3000`, `https://example.com` et `https://www.example.com` ne correspondent pas entre eux.

## Installer le script [#installer-le-script]

Collez le loader juste avant la balise de fermeture `</body>` sur chaque page qui doit afficher le lanceur. Remplacez uniquement le slug public du site et les valeurs de présentation facultatives.

```html
<script
  src="https://makeagent.fast/embed.js?v=20261022-open"
  data-agent="YOUR_SITE_SLUG"
  data-position="right"
  async
></script>
```

`data-agent` est obligatoire. Le slug est public ; aucune clé d'API n'a sa place dans cette balise. Conservez le paramètre `?v=` du snippet fourni par le tableau de bord. Les attributs facultatifs `data-label`, `data-accent` (`#RGB` / `#RRGGBB`), `data-locale` (`en` | `ko` | `uz` | `ru`) et `data-theme` (`light` | `dark`) sont décrits dans la [Présentation de l'intégration](/fr/docs/embed/overview). Omettez-les pour hériter des paramètres **Affichage** enregistrés et du comportement de thème automatique.

## Choisir un placement sur tout le site ou page par page [#choisir-un-placement-sur-tout-le-site-ou-page-par-page]

Pour un modèle côté serveur partagé, placez le script dans le layout ou le pied de page global. Pour certaines pages seulement, ajoutez-le uniquement dans les modèles concernés. Chargez le même slug une seule fois par document : les balises en double avec le même slug sont ignorées, mais les supprimer rend la gestion et le démontage plus prévisibles.

Ne collez pas le snippet dans un assainisseur HTML ni dans un champ de texte enrichi qui supprime `<script>`. Vérifiez que la balise figure toujours dans le code source de la page rendue ou dans le panneau Éléments.

## Supprimer ou remonter dans une SPA [#supprimer-ou-remonter-dans-une-spa]

Supprimer le script après son exécution ne supprime pas le lanceur qu'il a déjà créé. Une application cliente propre à une route doit supprimer à la fois le script et la racine propre au slug avant de remonter :

```js
const slug = "YOUR_SITE_SLUG";
document.getElementById("maf-agent")?.remove();
document.getElementById(`maf-embed-root-${slug}`)?.remove();
```

Il est préférable de garder une seule racine à l'échelle du site, montée pendant la navigation côté client, afin que la conversation en cours ne soit pas perdue. Si vous supprimez la racine, ajoutez un nouveau script `embed.js` pour la recréer.

## Vérifier dans le navigateur [#vérifier-dans-le-navigateur]

1. Ouvrez la page déployée dans une fenêtre privée.
2. Vérifiez que `embed.js` renvoie `200` et n'est bloqué ni par la CSP ni par le consentement.
3. Vérifiez qu'une seule racine `[data-maf-embed="YOUR_SITE_SLUG"]` existe.
4. Ouvrez le lanceur et vérifiez que l'iframe `/embed/YOUR_SITE_SLUG` se charge.
5. Envoyez une question et vérifiez le fil dans **Conversations**.
6. Testez la largeur mobile et l'autorisation du microphone lorsque la voix est activée.

## Dépannage [#dépannage]

| Symptôme                                        | Solution                                                                                  |
| ----------------------------------------------- | ----------------------------------------------------------------------------------------- |
| La console signale un `data-agent` manquant     | Placez l'attribut sur la balise `embed.js` exacte                                         |
| Le script existe mais le lanceur n'apparaît pas | Vérifiez l'interrupteur d'intégration, l'origine exacte, la CSP et l'état du consentement |
| Fonctionne sur un seul nom d'hôte               | Ajoutez chaque combinaison schéma/hôte/port réelle à la liste d'autorisation              |
| Le style diffère de celui attendu               | Vérifiez `data-accent`, `data-theme` et l'apparence enregistrée du site                   |
| La voix échoue dans l'iframe                    | Autorisez le microphone dans le navigateur et dans la Permissions Policy de l'hôte        |

Ne faites jamais transiter le loader par un proxy et ne le copiez pas dans un fork local non vérifié ; utilisez le script hébergé afin que la validation d'origine et les correctifs restent à jour.

---

# Imweb

Source: /fr/docs/embed/imweb.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Imweb&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

Imweb (아임웹) est un créateur de sites web coréen utilisé par de nombreuses petites boutiques et de nombreux studios. Installez le lanceur avec le paramètre d'insertion de code propre à Imweb. Il n'existe aucune application Make Agent Fast dans un catalogue Imweb. Les noms de menus indiqués ici sont valables en date de 2026-09 ; si un libellé a changé, cherchez le paramètre d'après sa fonction plutôt que d'après son chemin exact.

## Ajouter le loader [#ajouter-le-loader]

1. Dans le tableau de bord Make Agent Fast, ouvrez **Mettre en ligne** → **Widget de site web** sur la page de l'agent, activez **Afficher sur mon site web**, puis ajoutez à **Adresses de site web autorisées** chaque origine servie par Imweb : votre domaine personnalisé et l'adresse gratuite `imweb.me` si vous l'utilisez encore.
2. Ouvrez les paramètres du site et trouvez la zone d'insertion de code : les champs qui permettent d'ajouter du balisage au `<head>` de chaque page ou à la fin du body. La disponibilité dépend de votre offre Imweb.
3. Collez l'extrait généré dans le champ head. Le loader est `async`, si bien que le head comme la fin du body fonctionnent.
4. Enregistrez et appliquez la modification au site en production, puis rechargez la boutique dans un nouvel onglet.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Si vous ne trouvez pas ce paramètre, collez plutôt l'extrait dans le bloc de pied de page de votre thème : un widget HTML placé dans une section de pied de page s'exécute sur toutes les pages qui utilisent cette section.

## Vérifier [#vérifier]

1. Ouvrez l'URL publiée dans une fenêtre de navigation privée, et non dans l'éditeur Imweb. Les modes éditeur et aperçu peuvent empêcher l'exécution des scripts injectés.
2. Vérifiez que l'origine affichée dans la barre d'adresse est bien celle que vous avez autorisée, avec `www` si le domaine redirige vers cette version.
3. Vérifiez que `embed.js` renvoie `200` dans le panneau Réseau et qu'un seul élément `data-maf-embed="YOUR_SITE_SLUG"` existe.
4. Posez une question réaliste et vérifiez que le message apparaît dans **Conversations**.

## Dépannage [#dépannage]

| Symptôme                                               | Cause probable                                                                          | Solution                                                   |
| ------------------------------------------------------ | --------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| Rien ne se charge sur le domaine personnalisé          | Seule l'adresse `imweb.me` a été autorisée                                              | Ajoutez également l'origine exacte du domaine personnalisé |
| Le lanceur apparaît deux fois                          | L'extrait se trouve à la fois dans le champ head et dans un widget HTML de pied de page | Conservez une seule copie, dans le champ head              |
| Le lanceur chevauche un bouton flottant de la boutique | Deux éléments fixes occupent le même coin                                               | Changez le coin du lanceur avec `data-position`            |

Si la boutique utilise une bannière de consentement ou un bloqueur de scripts, classez l'intégration dans la bonne catégorie de votre politique de consentement et chargez-la en conséquence. [Sécurité et CSP](/fr/docs/embed/security) répertorie les origines à autoriser.

---

# Notion et Linktree

Source: /fr/docs/embed/notion-linktree.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l’intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Notion&#x22;, icon: &#x22;notion&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

Les pages Notion et les profils Linktree ne permettent pas d'exécuter du JavaScript arbitraire sur l'ensemble du site, ce qui empêche d'utiliser le widget flottant. Partagez plutôt le **lien de l'agent** : une page de chat publique unique, à l'adresse propre de votre agent.

## Ajouter un lien [#ajouter-un-lien]

1. À la dernière étape de l'onboarding, activez **Lien de l'agent** sous **Testez sur votre téléphone**. Le même interrupteur se trouve dans l'onglet **Affichage** de la page de l'agent.
2. Copiez l'URL réelle du lien de l'agent affichée par Make Agent Fast. N'inventez ni le slug de l'agent ni le domaine.
3. Ajoutez un lien ou un signet Notion, ou un lien Linktree tel que **Discuter avec notre agent**.
4. Ouvrez le lien sur votre téléphone. Toute personne disposant du lien peut discuter avec l'agent tant que la page est activée ; si vous la désactivez, la page devient indisponible.

Votre site web n'a pas besoin du script pour que ce lien fonctionne. Si vous préférez renvoyer vers votre propre site, installez d'abord le widget sur celui-ci, puis utilisez l'URL de cette page. Un lien classique est plus fiable que l'intégration de la page dans l'iframe d'une autre plateforme, qui peut limiter l'accès au microphone et la mise en page.

---

# Présentation de l'intégration

Source: /fr/docs/embed/overview.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/html&#x22;, label: &#x22;HTML&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/react-next&#x22;, label: &#x22;React&#x22;, icon: &#x22;react&#x22; },
{ href: &#x22;/fr/docs/embed/vue-nuxt&#x22;, label: &#x22;Vue&#x22;, icon: &#x22;vue&#x22; },
{ href: &#x22;/fr/docs/embed/sveltekit&#x22;, label: &#x22;SvelteKit&#x22;, icon: &#x22;svelte&#x22; },
{ href: &#x22;/fr/docs/embed/astro&#x22;, label: &#x22;Astro&#x22;, icon: &#x22;astro&#x22; },
{ href: &#x22;/fr/docs/embed/wordpress&#x22;, label: &#x22;WordPress&#x22;, icon: &#x22;wordpress&#x22; },
{ href: &#x22;/fr/docs/embed/shopify&#x22;, label: &#x22;Shopify&#x22;, icon: &#x22;shopify&#x22; },
{ href: &#x22;/fr/docs/embed/webflow&#x22;, label: &#x22;Webflow&#x22;, icon: &#x22;webflow&#x22; },
{ href: &#x22;/fr/docs/embed/framer&#x22;, label: &#x22;Framer&#x22;, icon: &#x22;framer&#x22; },
{ href: &#x22;/fr/docs/embed/wix&#x22;, label: &#x22;Wix&#x22;, icon: &#x22;wix&#x22; },
{ href: &#x22;/fr/docs/embed/squarespace&#x22;, label: &#x22;Squarespace&#x22;, icon: &#x22;squarespace&#x22; },
{ href: &#x22;/fr/docs/embed/ghost&#x22;, label: &#x22;Ghost&#x22;, icon: &#x22;ghost&#x22; },
{ href: &#x22;/fr/docs/embed/notion-linktree&#x22;, label: &#x22;Notion&#x22;, icon: &#x22;notion&#x22; },
{ href: &#x22;/fr/docs/embed/tilda&#x22;, label: &#x22;Tilda&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/imweb&#x22;, label: &#x22;Imweb&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/cafe24&#x22;, label: &#x22;Cafe24&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: &#x22;CSP&#x22;, icon: &#x22;shield&#x22; }
]"
/>

<TutorialVideo episode="ep02" />

## Fonctionnement de l'intégration [#fonctionnement-de-lintégration]

`embed.js` ajoute un lanceur fixe au document hôte. Il peut précharger l'iframe masquée depuis `https://makeagent.fast` afin d'évaluer les déclencheurs de page avant le premier clic ; le visiteur ouvre le chat complet depuis le lanceur ou un déclencheur. Le CSS de l'hôte ne peut pas modifier le style du chat. Les modifications de la page hôte ne s'exécutent que via des [gestionnaires d'actions de page](/fr/docs/build/page-actions) enregistrés et approuvés par le propriétaire.

Le loader est public et n'utilise **pas** de clé API. L'accès est contrôlé par l'interrupteur **Afficher sur mon site web** de l'agent et par la liste d'autorisation des origines parentes exactes (**Adresses de site web autorisées**). Le slug du site est un identifiant, pas un secret.

## Prérequis [#prérequis]

Avant de copier le code :

1. Créez et testez un agent dans le tableau de bord.
2. Utilisez l'extrait généré pour l'agent ; il n'est pas nécessaire d'activer son **Lien de l'agent** distinct.
3. Sur la page **Agent** de l'agent, ouvrez **Mettre en ligne** → **Widget de site web**. Si le widget n'est pas encore activé, choisissez **Activer l'intégration**, puis vérifiez que **Afficher sur mon site web** est activé.
4. Sous **Adresses de site web autorisées**, ajoutez chaque origine parente qui affichera le lanceur.
5. Sélectionnez **Enregistrer les paramètres d'intégration**, puis copiez l'extrait généré.

Une origine contient uniquement le schéma, le nom d'hôte et, éventuellement, le port. Elle ne contient jamais de chemin. Les quatre origines suivantes sont distinctes et doivent être ajoutées séparément lorsque vous les utilisez :

```text
https://example.com
https://www.example.com
https://staging.example.com
http://localhost:3000
```

Ne saisissez pas `https://example.com/pricing`, `*.example.com` ni de caractère générique final. Si la production redirige le domaine nu vers `www`, autorisez l'origine qui reste dans la barre d'adresse du navigateur après la redirection.

## Installer le loader [#installer-le-loader]

Placez un seul script avant la balise de fermeture `</body>`, ou utilisez le cycle de vie réservé au navigateur recommandé par le guide de votre framework.

La feuille **Widget de site web** (page Agent → **Mettre en ligne**) copie la structure suivante (slug du site, position, libellé facultatif et paramètre `?v=` de contournement du cache). Conservez `async`. Gardez le paramètre `?v=` de l'extrait afin que les sites hôtes ne conservent pas un loader obsolète.

```html
<script
  src="https://makeagent.fast/embed.js?v=20261022-open"
  data-agent="YOUR_SITE_SLUG"
  data-position="right"
  async
></script>
```

Seul `data-agent` est obligatoire. Attributs facultatifs réellement lus par le loader :

```html
<script
  src="https://makeagent.fast/embed.js?v=20261022-open"
  data-agent="YOUR_SITE_SLUG"
  data-position="right"
  data-label="Ask us"
  data-accent="#6d5ce7"
  data-locale="en"
  data-theme="light"
  async
></script>
```

Ne placez jamais de clé API MAF, de clé de fournisseur, de jeton de connecteur, d'identité de visiteur ni de données privées de clients dans un attribut `data-*`. N'inventez pas d'attributs tels que `data-api-key`, `data-z-index`, `data-offset` ou `data-delay`. `data-maf-bootstrapped` est défini par le loader.

## Configurer les attributs [#configurer-les-attributs]

Lus uniquement depuis la balise `embed.js`. L'iframe n'accepte que les couleurs d'accent hexadécimales.

| Attribut               | Valeur acceptée                                                                                                   | Valeur par défaut                | Effet                                                                                                                                                                                              |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------- | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `data-agent`           | Slug du site de l'agent                                                                                           | Obligatoire                      | Sélectionne le site et l'agent. Absent → avertissement dans la console, aucun lanceur                                                                                                              |
| `data-position`        | `bottom-left`, `bottom-right`, `top-left`, `top-right` (`left` / `right` désignent toujours les coins inférieurs) | `right` (en bas à droite)        | Toute autre valeur est traitée comme en bas à droite                                                                                                                                               |
| `data-label`           | Texte brut                                                                                                        | Icône seule                      | Texte visible du lanceur et nom accessible. Échappez `"` et `<`. L'interface du tableau de bord limite à 40 caractères                                                                             |
| `data-accent`          | `#RGB` ou `#RRGGBB`                                                                                               | Apparence enregistrée du site    | Remplacement côté hôte pour le lanceur ; les valeurs non hexadécimales sont ignorées dans l'iframe                                                                                                 |
| `data-locale`          | `en`, `ko`, `uz` ou `ru`                                                                                          | Langue principale de l'agent     | Langue d'ouverture de l'agent sur cette page hôte, choisie parmi ses langues activées                                                                                                              |
| `data-theme`           | `light` ou `dark`                                                                                                 | Arrière-plan de l'hôte, sinon OS | Les autres valeurs sont ignorées                                                                                                                                                                   |
| `data-auto-form-error` | `true`                                                                                                            | Désactivé                        | Active les événements de déclenchement sur erreur de formulaire ; transmet l'identifiant du formulaire, jamais les valeurs des champs                                                              |
| `data-analytics`       | `off` (également `false`, `0`, `no`)                                                                              | Activé                           | À utiliser lorsque votre visiteur n'a pas consenti aux statistiques : le cadre du chat ne charge aucune analyse de page et n'envoie aucune balise de vue. Le chat lui-même continue de fonctionner |

La racine générée utilise également `data-maf-open` en interne pour savoir si le chat est ouvert. Ce n'est ni un paramètre de la balise script ni une commande publique pour ouvrir le widget. Consultez [Relances](/fr/docs/build/follow-ups) pour le comportement des déclencheurs.

Sans `data-theme`, le loader échantillonne l'arrière-plan de l'hôte, puis se rabat sur la préférence du système d'exploitation du visiteur. Il transmet également la famille de polices de l'hôte au cadre et récupère la dernière apparence du lanceur. Si cette requête d'apparence échoue, le lanceur n'est pas bloqué ; il conserve le style par défaut sûr. Les modifications dans **Affichage** du tableau de bord actualisent cette récupération sans republier le site.

## Comportement à l'exécution [#comportement-à-lexécution]

* Chargez le script une seule fois par document. Répéter le même slug est idempotent et ne produit toujours qu'une seule racine `maf-embed-root-YOUR_SITE_SLUG`.
* Plusieurs agents différents peuvent coexister sur un même document. Le loader marque chaque script traité avec `data-maf-bootstrapped`, de sorte qu'un chargement de secours asynchrone initialise chaque balise `data-agent` distincte une seule fois.
* L'iframe peut se précharger pour les déclencheurs de page. Elle reste masquée jusqu'à l'apparition d'un déclencheur ou jusqu'à ce que le visiteur ouvre le chat ; les sessions ayant déjà utilisé un déclencheur conservent le chemin d'ouverture différée. Le microphone, la lecture automatique et l'écriture dans le presse-papiers restent soumis au modèle d'autorisations des iframes du navigateur.
* Dans une application à routage côté client, montez le loader dans le layout le plus élevé qui doit le gérer, afin que les changements de route ne rechargent pas la conversation.
* Supprimer uniquement l'élément script ne supprime pas un lanceur déjà créé. Pour un démontage propre à une route, supprimez également l'élément `maf-embed-root-...` correspondant. Rechargez le script après le démontage pour le monter à nouveau.
* Le cadre et le loader échangent des messages d'espace de noms concernant le cycle de vie, l'identité, les déclencheurs et les actions de page. Le loader rejette les messages qui ne proviennent pas de l'origine Make Agent Fast et du slug de site actuel.

## Vérifier l'installation [#vérifier-linstallation]

Testez la page publiée, et pas seulement l'aperçu de l'éditeur d'un créateur de sites :

1. Ouvrez l'URL déployée dans une fenêtre privée et vérifiez que son origine exacte figure dans la liste d'autorisation.
2. Vérifiez que `https://makeagent.fast/embed.js?v=20261022-open` renvoie `200` dans le panneau Réseau.
3. Vérifiez qu'il existe un seul élément avec `data-maf-embed="YOUR_SITE_SLUG"`.
4. Ouvrez le lanceur et vérifiez que la requête de l'iframe vers `/embed/YOUR_SITE_SLUG` aboutit.
5. Envoyez une question réaliste et vérifiez qu'elle apparaît dans **Conversations**.
6. Testez une fenêtre d'affichage mobile étroite et, si elle est activée, l'autorisation du microphone.

## Diagnostiquer un lanceur manquant [#diagnostiquer-un-lanceur-manquant]

| Symptôme                                               | Cause probable                                                               | Solution                                                                                                |
| ------------------------------------------------------ | ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
| La console avertit `missing data-agent`                | L'attribut slug est absent ou placé sur un autre script                      | Placez `data-agent` sur la balise `embed.js`                                                            |
| `embed.js` est bloqué                                  | Une CSP ou un gestionnaire de consentement a rejeté le script                | Autorisez l'origine du script ou chargez-le après le consentement requis                                |
| Le lanceur apparaît mais le cadre refuse de se charger | L'intégration est désactivée ou l'origine parente diffère                    | Revérifiez **Afficher sur mon site web** et **Adresses de site web autorisées** dans le tableau de bord |
| Fonctionne sur localhost mais pas en production        | Seule l'origine de développement est autorisée                               | Ajoutez l'origine HTTPS exacte du site déployé                                                          |
| Deux agents différents apparaissent                    | Le document charge deux slugs différents                                     | Ne conservez que le slug du site souhaité                                                               |
| Le chat s'ouvre mais pas la voix                       | Une autorisation du navigateur ou la Permissions Policy bloque le microphone | Suivez [Sécurité et CSP](/fr/docs/embed/security)                                                       |

## Choisir un guide d'installation [#choisir-un-guide-dinstallation]

Utilisez [HTML et JavaScript](/fr/docs/embed/html) pour une balise script classique. Pour React, Vue, SvelteKit, Astro, WordPress, Shopify, Webflow, Framer, Wix, Squarespace ou Ghost, choisissez le guide correspondant dans la barre latérale. Les plateformes qui n'autorisent pas de JavaScript arbitraire, comme de nombreuses surfaces Notion et Linktree, peuvent renvoyer vers le **Lien de l'agent** : une page de chat publique à l'adresse propre de l'agent, activée à la dernière étape de l'intégration (**Testez sur votre téléphone**) et dans l'onglet **Affichage** de la page Agent. Un site web client doté de l'intégration est une autre option.

## Pour les agents de code [#pour-les-agents-de-code]

Vous installez ceci sur le site d'un client avec Claude Code, Cursor ou Codex ? Copiez `skills/embed-agent/SKILL.md` depuis le dépôt Make Agent Fast dans `.cursor/skills/embed-agent/` ou `.claude/skills/embed-agent/`. Ce fichier constitue la recette d'installation (attributs, CSP, emplacement). Cette page reste le guide destiné aux humains.

---

# React et Next.js

Source: /fr/docs/embed/react-next.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l’intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;React&#x22;, icon: &#x22;react&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Préparer les origines et le périmètre [#préparer-les-origines-et-le-périmètre]

Activez **Afficher sur mon site web** pour l’agent (page de l’agent → **Mettre en ligne** → **Widget de site web**), puis ajoutez les origines exactes de développement local, de préproduction et de production sous **Adresses de site web autorisées**. Déterminez si le lanceur doit persister lors de chaque navigation côté client (layout racine) ou n’exister que sous certaines routes (layout ou composant imbriqué).

## Next.js App Router [#nextjs-app-router]

Utilisez `next/script` dans un composant rendu par le layout qui possède le lanceur. Le slug peut être exposé sans risque ; n’utilisez pas de clé API ni de variable d’environnement secrète.

```tsx
import Script from "next/script";

export function AgentEmbed() {
  return (
    <Script
      id="maf-agent"
      src="https://makeagent.fast/embed.js?v=20261022-open"
      strategy="afterInteractive"
      data-agent="YOUR_SITE_SLUG"
      data-position="right"
      data-label="Ask us"
    />
  );
}
```

Rendez `<AgentEmbed />` une seule fois dans `app/layout.tsx` pour un agent disponible sur tout le site, ou dans un layout imbriqué pour un groupe de routes. Ne rendez pas une copie distincte depuis chaque composant de page. `afterInteractive` évite tout accès au DOM côté serveur et ne bloque pas l’analyse du HTML initial.

Avec le Pages Router de Next.js, rendez ce même composant une seule fois depuis `pages/_app.tsx` pour un comportement sur l’ensemble du site. Le rendre depuis une page individuelle n’est approprié que si le fait de quitter cette page doit retirer l’agent ; dans ce cas, utilisez le modèle explicite effet/nettoyage ci-dessous, car un script externe chargé a déjà créé du DOM en dehors de l’arbre de React.

## React sans Next.js [#react-sans-nextjs]

Créez le script dans un effet. Un identifiant de script stable empêche une double insertion en mode Strict de développement. Si le composant est limité à une route, le nettoyage doit supprimer à la fois le script et la racine créée par le loader.

```tsx
import { useEffect } from "react";

const slug = "YOUR_SITE_SLUG";

export function AgentEmbed() {
  useEffect(() => {
    if (document.getElementById(`maf-embed-root-${slug}`)) return;

    const script = document.createElement("script");
    script.id = "maf-agent";
    script.src = "https://makeagent.fast/embed.js?v=20261022-open";
    script.dataset.agent = slug;
    script.dataset.position = "right";
    script.async = true;
    document.body.appendChild(script);

    return () => {
      script.remove();
      document.getElementById(`maf-embed-root-${slug}`)?.remove();
    };
  }, []);

  return null;
}
```

Pour un lanceur disponible sur tout le site, montez ce composant au-dessus du routeur et évitez le démontage lié aux routes. Conserver la racine préserve l’iframe et la conversation d’une navigation à l’autre.

## Configuration de l’environnement [#configuration-de-lenvironnement]

Une variable publique définie au moment du build peut contenir le **slug**, car il n’est pas secret. Validez-le avant le rendu et conservez les véritables clés API MAF et identifiants de fournisseurs exclusivement côté serveur. Si le slug est manquant, le loader émet un avertissement et s’arrête au lieu de créer un lanceur.

Si votre application sert plusieurs tenants clients à partir d’un même build React, ne modifiez pas `data-agent` sur un script déjà exécuté. Attribuez un slug stable unique au tenant courant, supprimez la racine de l’ancien slug lors d’un changement de tenant authentifié, puis montez un nouveau script. Ne laissez jamais un paramètre de requête non fiable déterminer un slug d’un autre tenant.

## Vérifier l’hydratation et la navigation [#vérifier-lhydratation-et-la-navigation]

1. Chargez directement une route publique et vérifiez qu’un seul lanceur apparaît.
2. Naviguez côté client entre les routes qui doivent conserver le lanceur.
3. Pour une installation imbriquée ou limitée à une route, quittez la route et vérifiez que le script et la racine disparaissent, puis revenez et vérifiez qu’un seul nouveau lanceur apparaît.
4. Inspectez le réseau et la CSP, puis testez un vrai message.
5. Exécutez le build de production ; le mode Strict en développement ne reflète pas à lui seul le comportement final.

## Dépannage [#dépannage]

| Symptôme                                                 | Solution                                                                                          |
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| `document is not defined`                                | Du code DOM s’est exécuté pendant le SSR ; déplacez-le dans `useEffect` ou utilisez `next/script` |
| Deux lanceurs/agents apparaissent                        | Plusieurs slugs ou composants sont montés ; conservez un seul layout responsable                  |
| Le lanceur reste après avoir quitté la route             | Supprimez `maf-embed-root-SLUG` lors du nettoyage, et pas seulement le script                     |
| Le lanceur disparaît à chaque navigation                 | Montez-le plus haut dans l’arbre du layout ou du routeur                                          |
| Fonctionne en local mais pas en préproduction/production | Autorisez l’origine exacte de chaque déploiement                                                  |

Aucun adaptateur npm pour React ou Next n’est actuellement publié ; ces exemples utilisent le loader public pris en charge, indépendant de l’API REST.

---

# Sécurité et CSP

Source: /fr/docs/embed/security.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; },
{ href: &#x22;/fr/docs/build/appearance&#x22;, label: 'Apparence', icon: &#x22;spark&#x22; }
]"
/>

## Liste d'origines autorisées [#liste-dorigines-autorisées]

L'intégration est refusée par défaut, sauf si elle est activée et si l'origine parente exacte du navigateur est autorisée. Une origine se présente sous la forme `scheme://hostname[:port]` ; les chemins et les chaînes de requête n'en font pas partie.

| Page hôte                               | Valeur de la liste d'autorisation  |
| --------------------------------------- | ---------------------------------- |
| `https://example.com/pricing`           | `https://example.com`              |
| `https://www.example.com/help`          | `https://www.example.com`          |
| `https://preview.example.com:8443/demo` | `https://preview.example.com:8443` |
| `http://localhost:3000`                 | `http://localhost:3000`            |

Ajoutez séparément les origines de production, de préproduction et locales. N'ajoutez pas de caractère générique pour résoudre une erreur d'installation : sinon, toute personne qui copie un slug public pourrait intégrer l'agent et consommer les crédits du site.

## Content Security Policy [#content-security-policy]

Le loader a besoin de l'autorisation de script, le widget a besoin de l'autorisation de frame, et la requête d'apparence du loader peut nécessiter l'autorisation de connexion. Fusionnez ces sources dans les directives existantes de l'hôte ; ne remplacez pas une politique déjà éprouvée par cet exemple minimal.

```http
Content-Security-Policy:
  default-src 'self';
  script-src 'self' https://makeagent.fast;
  frame-src https://makeagent.fast;
  connect-src 'self' https://makeagent.fast;
```

Si le site utilise `script-src-elem`, ajoutez-y également `https://makeagent.fast`. Le loader externe n'exige pas `unsafe-inline`, mais le framework de l'hôte peut avoir ses propres exigences en matière de nonce ou de hash. Une politique en mode « report-only » est utile pendant les tests :

```http
Content-Security-Policy-Report-Only:
  script-src 'self' https://makeagent.fast;
  frame-src https://makeagent.fast;
  connect-src 'self' https://makeagent.fast;
```

Lorsque la console du navigateur signale une violation de CSP, modifiez la directive indiquée, et non `default-src` de façon générale, puis testez à nouveau la page publique.

## Microphone et autorisations du navigateur [#microphone-et-autorisations-du-navigateur]

Le loader crée l'iframe avec `allow="microphone; autoplay; clipboard-write"`. Une Permissions Policy plus stricte au niveau de l'hôte peut toutefois annuler cette autorisation. Si la voix est activée, autorisez l'origine de la frame Make Agent Fast dans la réponse de l'hôte :

```http
Permissions-Policy: microphone=(self "https://makeagent.fast")
```

Le visiteur doit également accorder l'accès au microphone dans le navigateur. Testez en HTTPS : les navigateurs restreignent normalement l'accès au microphone sur les origines publiques non sécurisées. Le chat textuel ne nécessite pas l'autorisation du microphone.

## Limite entre messages et frame [#limite-entre-messages-et-frame]

Le loader n'accepte que `maf:ready`, `maf:open`, `maf:close` et les messages de cycle de vie du thème associés au slug du site en cours. Les messages entrants de la frame sont vérifiés par rapport à `https://makeagent.fast`. Ne copiez pas le loader dans votre propre bundle et ne supprimez pas cette validation d'origine.

Le code de la page hôte ne doit pas tenter d'accéder au DOM de l'iframe. La frame est volontairement cross-origin ; la surface d'intégration prise en charge se compose du loader, de ses attributs `data-*` documentés et des méthodes d'identité ci-dessous.

## Secrets et identité des visiteurs [#secrets-et-identité-des-visiteurs]

Le slug du site et l'URL du loader sont publics. Tout le reste doit rester absent du code source de la page :

* N'ajoutez jamais au snippet une clé API MAF, un jeton OAuth, une clé de fournisseur d'IA, un jeton de connecteur ou un secret de webhook.
* N'intégrez jamais un secret dans un bundle JavaScript et ne l'exposez pas via `NEXT_PUBLIC_*`, `VITE_*` ou des variables d'environnement de navigateur similaires.
* Utilisez une intégration API côté serveur lorsque votre application doit créer des sites, mettre à jour des agents ou récupérer des données privées de l'espace de travail.
* Ne placez pas d'adresses e-mail, d'identifiants de compte ou d'autres données de visiteurs dans `data-label`, `data-locale` ou les paramètres de requête.

## Identifier les clients connectés [#identifier-les-clients-connectés]

Dans **Agent → Actions → Clients connectés**, créez un secret et copiez-le lorsqu'il s'affiche. Conservez-le uniquement sur votre serveur sous le nom `MAF_SECRET_KEY` ; ne le placez jamais dans du code navigateur, des variables d'environnement publiques ou un dépôt. Ce secret d'agent est distinct d'une clé API d'espace de travail. La rotation invalide les anciens jetons et modifie la clé de signature des [recherches](/fr/docs/build/lookups) ; la suppression désactive l'identité vérifiée des clients et les recherches jusqu'à la configuration d'un nouveau secret.

Utilisez l'URL de loader mise à jour `https://makeagent.fast/embed.js?v=20261022-open` dans votre snippet existant. Les anciennes URL versionnées peuvent rester en cache pendant un an et ne fournissent pas ce SDK. Conservez votre liste d'origines autorisées et vos protections CSP.

Votre serveur authentifié doit émettre le jeton à partir du client présent dans sa propre session. N'acceptez jamais un identifiant client arbitraire provenant du navigateur comme identité à signer. Cette fonction utilitaire s'exécute **uniquement sur le serveur** :

```js
import { createHmac } from "node:crypto";

export function signCustomerIdentity(customer) {
  const secret = process.env.MAF_SECRET_KEY;
  if (!secret) throw new Error("MAF_SECRET_KEY is required");
  const encode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
  const now = Math.floor(Date.now() / 1000);
  const header = encode({ alg: "HS256", typ: "JWT" });
  const payload = encode({
    sub: customer.id,
    email: customer.email,
    name: customer.name,
    iat: now,
    exp: now + 3600,
  });
  const body = `${header}.${payload}`;
  const signature = createHmac("sha256", secret).update(body).digest("base64url");
  return `${body}.${signature}`;
}
```

Exigez l'en-tête `alg: "HS256"` et `typ: "JWT"`. `sub` est une chaîne stable et non vide de 128 caractères maximum ; `exp` est un horodatage Unix entier en secondes, situé dans le futur et au plus 24 heures plus tard. `iat`, facultatif, est un entier ; `email`, facultatif, doit être valide et comporter au plus 160 caractères ; `name`, facultatif, comporte au plus 120 caractères. Le jeton complet doit tenir dans 2 048 caractères. Omettez les claims facultatifs dont vous n'avez pas besoin. Les payloads JWT sont signés, mais pas chiffrés.

Renvoyez uniquement le jeton à cette session de navigateur authentifiée via HTTPS, avec `Cache-Control: no-store`. Ne le journalisez pas, ne l'ajoutez pas aux URL et ne le stockez pas dans localStorage. Une fois `embed.js` chargé, transmettez le jeton de cette réponse au widget :

```js
window.MakeAgentFast.identify(token);
```

Pour une initialisation avant l'exécution du loader, définissez plutôt `window.MakeAgentFastSettings = { identityToken: token }` dans le bootstrap de votre application. Le loader conserve le dernier jeton en mémoire et le transmet lorsque la frame est prête. Actualisez le jeton depuis votre serveur authentifié avant son expiration et appelez de nouveau `identify`. Chaque requête de chat l'inclut ; les requêtes de conversation utilisent `x-maf-identity`. Une identité d'hôte vérifiée ne repose jamais sur un cookie `af_xid`.

Lorsque votre application déconnecte l'utilisateur, appelez ceci avant d'afficher le chat d'un autre compte, et effacez tout jeton de bootstrap conservé par votre application :

```js
window.MakeAgentFast.logout();
```

Cela réinitialise l'identité du widget et le cache local des conversations ; cela ne déconnecte pas le client de votre propre application et ne révoque pas un jeton copié. Un `sub` différent d'un autre client efface également le cache du widget. Les jetons invalides, expirés ou destinés à un autre agent ne peuvent pas accéder à l'historique de ce client connecté et basculent vers le parcours visiteur ordinaire. Utilisez des durées d'expiration courtes et gardez le secret de chaque agent séparé. La répétition côté propriétaire ignore les jetons d'identité ; vérifiez l'isolation sur l'intégration réelle avec deux comptes de test distincts.

## Consentement, confidentialité et conservation [#consentement-confidentialité-et-conservation]

Classez l'intégration conformément à votre politique de confidentialité et de consentement. Si votre gestionnaire de consentement bloque les scripts tiers non essentiels, ne chargez `embed.js` qu'après le consentement concerné. D'ici là, affichez un lien classique ou un espace réservé désactivé plutôt que de contourner le gestionnaire.

Informez les visiteurs lorsque l'expérience utilise l'IA, l'enregistrement du microphone, la collecte de leads, l'analytique ou un fournisseur de messagerie externe, comme l'exigent votre politique et la législation applicable. Confirmez le processus de conservation et de suppression des conversations de votre site avant le lancement ; déconnecter ou supprimer l'intégration ne supprime pas, à lui seul, les conversations existantes.

## Liste de contrôle de sécurité avant le lancement [#liste-de-contrôle-de-sécurité-avant-le-lancement]

* Le site web du client est déployé, et son agent intégré est activé et testé.
* Seules les origines parentes exactes et prévues figurent dans la liste d'autorisation.
* La CSP de l'hôte autorise le script, la frame et la requête d'apparence sans caractères génériques trop larges.
* Le microphone n'est autorisé que si la voix est activée et a été testée en HTTPS.
* Aucun identifiant ni aucune valeur privée de visiteur n'apparaît dans le HTML, la sortie du bundle ou les journaux du navigateur.
* Le comportement du gestionnaire de consentement est testé avant et après consentement.
* Un snippet copié échoue sur une origine absente de la liste d'autorisation.

---

# Shopify

Source: /fr/docs/embed/shopify.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Shopify&#x22;, icon: &#x22;shopify&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Disponibilité de l'extension de thème [#disponibilité-de-lextension-de-thème]

Le code source de l'extension d'application de thème se trouve dans `integrations/shopify`. Il s'agit d'un modèle de développement, et non d'une application publique du Shopify App Store. Un compte Partner autorisé doit l'intégrer dans une application, la déployer et passer la validation de Shopify avant que les marchands puissent l'installer depuis l'App Store.

## Custom Liquid [#custom-liquid]

Dans **Boutique en ligne → Thèmes → Personnaliser**, ajoutez un bloc Custom Liquid lorsque cette option est disponible, ou modifiez `theme.liquid` et placez le script avant `</body>`.

```liquid
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Ajoutez à la liste d'autorisation l'origine canonique de votre boutique. Les noms d'hôte de prévisualisation peuvent différer du domaine `myshopify.com` en production ou du nom d'hôte propre à la boutique ; vous devez les ajouter séparément pour effectuer vos tests.

## Modifications du thème [#modifications-du-thème]

Vérifiez de nouveau l'intégration de l'application après la publication d'un nouveau thème. Testez le lanceur à proximité des tiroirs du panier, des bannières de consentement et de la navigation mobile afin que les éléments fixes ne se chevauchent pas.

---

# Squarespace

Source: /fr/docs/embed/squarespace.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Squarespace&#x22;, icon: &#x22;squarespace&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

Pour un lanceur sur l'ensemble du site, collez l'extrait de code dans **Paramètres → Avancé → Injection de code → Pied de page** si votre formule Squarespace le permet.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Pour certaines pages seulement, utilisez un bloc de code pris en charge ou une injection de code propre à la page. Testez après l'enregistrement et sur le domaine public : le mode éditeur peut empêcher l'exécution des scripts personnalisés.

Si une configuration de consentement aux cookies bloque les scripts tiers, classez l'intégration dans la catégorie appropriée et chargez-la conformément à votre politique de consentement.

---

# SvelteKit

Source: /fr/docs/embed/sveltekit.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;SvelteKit&#x22;, icon: &#x22;svelte&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Préparer l'origine [#préparer-lorigine]

Activez **Afficher sur mon site web** pour l'agent (page de l'agent → **Mettre en ligne** → **Widget de site web**), puis ajoutez chaque origine exacte SvelteKit de développement, de prévisualisation et de production sous **Adresses de site web autorisées**. Utilisez un layout racine pour un lanceur disponible sur l'ensemble du site, ou un layout/composant de page imbriqué pour des routes précises.

## Créer le composant [#créer-le-composant]

`onMount` ne s'exécute que dans le navigateur. Renvoyez une fonction de nettoyage lorsque le layout ou le composant parent peut être démonté.

```svelte
<script lang="ts">
  import { onMount } from "svelte";

  const slug = "YOUR_SITE_SLUG";

  onMount(() => {
    if (document.getElementById(`maf-embed-root-${slug}`)) return;

    const script = document.createElement("script");
    script.id = "maf-agent";
    script.src = "https://makeagent.fast/embed.js?v=20261022-open";
    script.dataset.agent = slug;
    script.dataset.position = "right";
    script.async = true;
    document.body.appendChild(script);

    return () => {
      script.remove();
      document.getElementById(`maf-embed-root-${slug}`)?.remove();
    };
  });
</script>
```

Montez le composant une seule fois depuis `src/routes/+layout.svelte` pour toute l'application. Pour un groupe de routes, placez-le dans le `+layout.svelte` de ce groupe ; le nettoyage supprime le lanceur lorsque le visiteur quitte le groupe.

## Utiliser la configuration en toute sécurité [#utiliser-la-configuration-en-toute-sécurité]

Le slug public du site peut être une valeur d'environnement publique de SvelteKit, car il ne s'agit pas d'un identifiant secret. N'utilisez pas `$env/static/public` ni du code côté navigateur pour les clés API MAF, les clés de fournisseur d'IA ou les secrets des connecteurs. Conservez-les dans des modules ou des routes réservés au serveur.

## Conserver ou réinitialiser l'état de la conversation [#conserver-ou-réinitialiser-létat-de-la-conversation]

Si vous gardez le composant dans le layout racine, la même iframe est conservée lors de la navigation côté client. Un nettoyage limité à une route supprime volontairement cette iframe et son état en cours dans la page. Choisissez un seul comportement plutôt que de remonter le composant à chaque page.

## Vérifier le build de production [#vérifier-le-build-de-production]

1. Exécutez l'adaptateur/le build de production de SvelteKit.
2. Chargez directement la route publique et vérifiez qu'il n'y a qu'un seul lanceur/une seule racine.
3. Naviguez vers le layout concerné, puis en dehors.
4. Inspectez le réseau/la CSP et l'origine parente exacte.
5. Testez un vrai message, une fenêtre d'affichage étroite et le microphone s'il est activé.

## Dépannage [#dépannage]

| Symptôme                                                     | Solution                                                                                               |
| ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
| Erreur `document` pendant le SSR                             | Gardez tout le code du chargeur dans `onMount`                                                         |
| Le lanceur persiste après la sortie du layout                | Renvoyez la fonction de nettoyage et supprimez la racine générée                                       |
| La conversation est réinitialisée à chaque page              | Montez le composant dans un `+layout.svelte` parent persistant                                         |
| La protection contre les doublons empêche un nouveau montage | Assurez-vous que le nettoyage précédent a supprimé l'ancienne racine avant d'ajouter un nouveau script |
| Échec uniquement en production                               | Autorisez l'origine HTTPS finale et inspectez les en-têtes CSP de l'adaptateur                         |

Aucun adaptateur npm SvelteKit n'est actuellement publié ; le script hébergé est la seule interface d'intégration prise en charge.

---

# Tilda

Source: /fr/docs/embed/tilda.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Tilda&#x22;, icon: &#x22;html&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

Tilda publie un export statique : le lanceur s'installe donc avec la fonctionnalité de code personnalisé propre à Tilda. Il n'existe pas d'application Make Agent Fast dans un catalogue Tilda. Les noms de menus indiqués ici sont valables en date de 2026-09 ; si un libellé a changé de place, recherchez le paramètre d'après sa fonction plutôt que d'après son chemin exact.

## Ajouter le loader [#ajouter-le-loader]

1. Dans le tableau de bord Make Agent Fast, ouvrez **Mettre en ligne** → **Widget de site web** sur la page de l'agent, activez **Afficher sur mon site web** et ajoutez à **Adresses de site web autorisées** chaque origine servie par Tilda : votre domaine personnalisé et, pendant vos tests, l'adresse d'aperçu `tilda.ws` du projet.
2. Ouvrez les paramètres du site du projet et repérez la zone de code personnalisé / d'injection HTML : les champs qui insèrent du code dans le `<head>` de chaque page ou juste avant la balise de fermeture du body. La disponibilité dépend de votre offre Tilda.
3. Collez le snippet généré dans le champ head. Le loader est `async` : l'insertion dans le head comme en fin de body fonctionne donc.
4. Enregistrez, puis republiez les pages qui doivent afficher le lanceur. Tilda sert un export statique : le code global n'atteint les visiteurs qu'après une republication.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Si vous ne trouvez pas ce paramètre, collez plutôt le snippet dans le bloc de pied de page de votre thème : le bloc de code HTML de Tilda ajoute le lanceur uniquement à la page qui le contient, ce qui permet aussi de limiter l'agent à une seule page de destination.

## Vérifier [#vérifier]

1. Ouvrez l'URL publiée dans une fenêtre de navigation privée, et non dans l'éditeur Tilda. Les modes éditeur et aperçu peuvent bloquer les scripts injectés.
2. Vérifiez que l'origine affichée dans la barre d'adresse est bien celle que vous avez autorisée, y compris `www` si le domaine redirige vers cette version.
3. Vérifiez que `embed.js` renvoie `200` dans le panneau Réseau et qu'un seul élément `data-maf-embed="YOUR_SITE_SLUG"` existe.
4. Posez une question réaliste et vérifiez que le message apparaît dans **Conversations**.

## Dépannage [#dépannage]

| Symptôme                                                          | Cause probable                                                           | Solution                                                                     |
| ----------------------------------------------------------------- | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------- |
| Le lanceur s'affiche dans l'éditeur mais pas sur la page en ligne | Les pages n'ont pas été republiées après l'enregistrement du code global | Republiez chaque page qui doit afficher le lanceur                           |
| Le lanceur se charge mais la fenêtre de chat refuse de s'ouvrir   | L'origine en ligne n'est pas autorisée, ou l'intégration est désactivée  | Ajoutez l'origine publiée exacte et revérifiez **Afficher sur mon site web** |
| Le snippet n'apparaît que sur une seule page                      | Il a été ajouté via un bloc HTML au niveau de la page                    | Déplacez-le dans le champ d'injection head global au site                    |

Les options de consentement aux cookies et de performance des pages de Tilda peuvent différer le chargement des scripts tiers. Si le blocage par consentement est activé, chargez l'intégration dans la catégorie que votre politique lui attribue, et consultez [Sécurité et CSP](/fr/docs/embed/security) pour connaître les origines à autoriser.

---

# Vue et Nuxt

Source: /fr/docs/embed/vue-nuxt.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l’intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Vue&#x22;, icon: &#x22;vue&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Préparer l’intégration [#préparer-lintégration]

Activez **Afficher sur mon site web** pour l’agent (page de l’agent → **Mettre en ligne** → **Widget de site web**), puis ajoutez l’origine exacte de vos déploiements local, de prévisualisation et de production sous **Adresses de site web autorisées**. Déterminez si l’agent doit être présent dans toute l’application ou uniquement dans certains composants de route.

## Plugin Nuxt pour tout le site [#plugin-nuxt-pour-tout-le-site]

Créez un plugin `.client.ts` afin qu’aucun code DOM ne s’exécute pendant le rendu côté serveur. Nuxt le charge une seule fois dans le navigateur, ce qui garde le lanceur et la conversation stables lors de la navigation côté client.

```ts
// plugins/make-agent-fast.client.ts
const slug = "YOUR_SITE_SLUG";

export default defineNuxtPlugin(() => {
  if (document.getElementById(`maf-embed-root-${slug}`)) return;

  const script = document.createElement("script");
  script.id = "maf-agent";
  script.src = "https://makeagent.fast/embed.js?v=20261022-open";
  script.dataset.agent = slug;
  script.dataset.position = "right";
  script.dataset.label = "Ask us";
  script.async = true;
  document.body.appendChild(script);
});
```

Ne placez aucun secret dans `runtimeConfig.public` : seuls le slug public du site et les paramètres visuels ont leur place dans le navigateur. Les véritables clés d’API/de fournisseur MAF restent dans la configuration d’exécution privée du serveur.

Le plugin pour tout le site n’a volontairement aucun nettoyage au démontage : il suit la durée de vie de l’application Nuxt. Pendant le remplacement à chaud des modules (HMR) en développement, une racine précédente peut subsister jusqu’à un rechargement complet ; la protection par racine empêche l’apparition d’un second lanceur. Vérifiez le comportement final avec un build de production propre plutôt qu’en modifiant le plugin à répétition dans un même onglet resté ouvert longtemps.

## Composant Vue limité à certaines routes [#composant-vue-limité-à-certaines-routes]

Pour certaines routes, montez le script dans `onMounted` et supprimez à la fois le script et la racine générée dans `onBeforeUnmount`.

```vue
<script setup lang="ts">
import { onBeforeUnmount, onMounted } from "vue";

const slug = "YOUR_SITE_SLUG";
let script: HTMLScriptElement | null = null;

onMounted(() => {
  if (document.getElementById(`maf-embed-root-${slug}`)) return;
  script = document.createElement("script");
  script.id = "maf-agent";
  script.src = "https://makeagent.fast/embed.js?v=20261022-open";
  script.dataset.agent = slug;
  script.async = true;
  document.body.appendChild(script);
});

onBeforeUnmount(() => {
  script?.remove();
  document.getElementById(`maf-embed-root-${slug}`)?.remove();
});
</script>
```

Utilisez un seul composant responsable. Plusieurs composants avec des slugs différents créent volontairement plusieurs agents, ce qui est rarement souhaitable.

Si une application Vue change de tenant authentifié sans rechargement complet de la page, considérez-le comme un démontage/remontage explicite. Supprimez la racine de l’ancien slug, validez le slug public du nouveau tenant à partir d’un état d’application fiable, puis ajoutez un nouveau script. Modifier `script.dataset.agent` après l’exécution du loader ne redirige pas l’iframe existante vers un autre agent.

Les en-têtes de sécurité de votre hébergeur s’appliquent toujours au rendu Nuxt/Vue. Ajoutez l’origine du loader et du cadre à votre CSP, et n’autorisez le microphone que si la voix est activée ; un plugin exécuté uniquement côté client ne peut pas contourner une politique du navigateur définie au niveau de la réponse.

## Vérifier le SSR et le routage [#vérifier-le-ssr-et-le-routage]

1. Exécutez le build de production Nuxt/Vue et vérifiez qu’aucune erreur `document is not defined` n’apparaît.
2. Chargez directement une route contenant l’intégration et vérifiez qu’il n’y a qu’une seule racine.
3. Naviguez côté client et vérifiez le comportement pour tout le site par rapport à celui limité à certaines routes.
4. Inspectez `embed.js`, l’iframe, la CSP et l’origine exacte.
5. Envoyez un message et testez le comportement sur mobile ainsi que le microphone.

## Dépannage [#dépannage]

| Symptôme                                                 | Solution                                                                          |
| -------------------------------------------------------- | --------------------------------------------------------------------------------- |
| Le SSR plante                                            | Renommez le plugin Nuxt en `.client.ts` ou gardez le code DOM dans `onMounted`    |
| Le lanceur reste affiché après avoir quitté la route     | Supprimez la racine propre au slug dans `onBeforeUnmount`                         |
| Le lanceur est réinitialisé à chaque changement de route | Utilisez le plugin client/layout pour tout le site plutôt qu’un composant de page |
| Le domaine de prévisualisation échoue                    | Ajoutez séparément cette origine HTTPS exacte                                     |
| Le script est inséré deux fois                           | Utilisez un seul responsable stable et une protection par racine/ID               |

Aucun adaptateur npm pour Vue/Nuxt n’est actuellement publié ; ce guide utilise directement le loader hébergé pris en charge.

---

# Webflow

Source: /fr/docs/embed/webflow.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Webflow&#x22;, icon: &#x22;webflow&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Disponibilité [#disponibilité]

L'intégration prise en charge repose sur le code personnalisé. Il n'existe aujourd'hui aucune application Make Agent Fast publique sur la Webflow Marketplace. Le dossier `integrations/webflow` du dépôt contient le même extrait de code pour le pied de page que celui présenté ci-dessous, et non une application Webflow native.

## Code personnalisé [#code-personnalisé]

Ajoutez le script généré dans **Site settings → Custom code → Footer code** (Paramètres du site → Code personnalisé → Code du pied de page), puis publiez.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Le code personnalisé peut ne pas s'exécuter dans l'aperçu du Webflow Designer. Testez les domaines publiés de préproduction et de production, et ajoutez chaque origine que vous utilisez à la liste d'autorisation.

---

# Wix

Source: /fr/docs/embed/wix.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;Wix&#x22;, icon: &#x22;wix&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Disponibilité de l'élément personnalisé [#disponibilité-de-lélément-personnalisé]

Utilisez l'élément personnalisé présent dans `integrations/wix/make-agent-fast.js` ou la zone de code personnalisé approuvée de Wix, en fin de `body`. Cette source n'est pas une application publiée sur le Wix App Market. Une URL de fiche n'apparaîtra ici qu'une fois qu'une revue externe en aura approuvé et publié une.

## Code personnalisé [#code-personnalisé]

Dans les paramètres du site, ajoutez le loader généré en tant que code personnalisé en fin de `body`, puis appliquez-le aux pages souhaitées.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Wix peut servir les versions d'aperçu et en ligne d'un site depuis des hôtes différents. Ajoutez uniquement les hôtes dont vous avez besoin à **Adresses de site web autorisées**, puis republiez le site après toute modification.

---

# WordPress

Source: /fr/docs/embed/wordpress.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: 'Présentation de l\'intégration', icon: &#x22;embed&#x22; },
{ label: &#x22;WordPress&#x22;, icon: &#x22;wordpress&#x22; },
{ href: &#x22;/fr/docs/embed/security&#x22;, label: 'Sécurité et CSP', icon: &#x22;shield&#x22; }
]"
/>

## Code source du plugin (installation manuelle) [#code-source-du-plugin-installation-manuelle]

Le code source du plugin, installable manuellement, se trouve dans `integrations/wordpress/make-agent-fast`. Il n'est pas répertorié dans le répertoire WordPress.org. Compressez ce dossier au format zip, téléversez-le via **Extensions → Ajouter → Téléverser une extension**, puis configurez le slug publié dans **Réglages → Make Agent Fast**. Un lien vers le répertoire apparaîtra ici uniquement une fois que la validation par une revue externe aura été obtenue.

## HTML personnalisé [#html-personnalisé]

Si vous procédez à une installation manuelle, ajoutez le script standard à l'aide d'un thème enfant, d'un outil de gestion de scripts d'en-tête/pied de page fiable, ou d'un bloc HTML personnalisé autorisé par votre offre WordPress.

```html
<script src="https://makeagent.fast/embed.js?v=20261022-open"
        data-agent="YOUR_SITE_SLUG"
        async></script>
```

Ajoutez à la liste d'autorisation du tableau de bord l'origine de production ainsi que toute origine de préproduction distincte. Videz les caches de page et de CDN après avoir modifié le snippet.

<Callout title="Évitez de modifier un thème parent">
  Une mise à jour du thème parent peut écraser vos modifications directes. Utilisez le plugin manuel ou un thème enfant pour une installation durable.
</Callout>

---

# Concepts clés

Source: /fr/docs/getting-started/concepts.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;site&#x22;, title: &#x22;Site&#x22;, description: &#x22;L'unité de l'espace de travail : agent, affichage du widget, connaissances, intégration, Agent link et points d'entrée de messagerie. Le slug est l'identifiant d'intégration.&#x22; },
{ icon: &#x22;chat&#x22;, title: &#x22;Agent&#x22;, description: &#x22;L'identité, les instructions, les langues et la personnalité vocale et textuelle que rencontrent les visiteurs.&#x22; },
{ icon: &#x22;book&#x22;, title: &#x22;Connaissances&#x22;, description: &#x22;URL, fichiers, notes, FAQ et produits sur lesquels s'appuient les réponses.&#x22; },
{ icon: &#x22;connectors&#x22;, title: &#x22;Canaux&#x22;, description: &#x22;Intégrations et connecteurs de messagerie qui proposent le même agent ailleurs.&#x22; },
{ icon: &#x22;layers&#x22;, title: &#x22;Crédits&#x22;, description: &#x22;Unités mesurées pour l'utilisation des modèles, de la voix et de la plateforme selon votre offre.&#x22; }
]"
/>

## Espace de travail [#espace-de-travail]

Votre compte constitue la limite de l'espace de travail pour les sites, la facturation, les identifiants d'API et la gestion de l'équipe. L'accès à un espace de travail ne donne jamais accès à un autre.

## Site [#site]

Un site est l'unité de l'espace de travail. Il possède son agent, ses paramètres d'affichage du widget, ses connaissances, ses connecteurs, ses statistiques et ses conversations. Une offre peut limiter le nombre de sites que vous pouvez garder actifs. Les domaines personnalisés ne sont pas proposés. Le slug public est l'identifiant d'intégration (`data-agent`) et l'adresse de la page de chat **Agent link** de l'agent, et non un domaine que vous configurez.

## Agent [#agent]

L'agent est le comportement conversationnel rattaché à un site. Son persona et ses instructions déterminent sa manière de s'exprimer ; ses connaissances déterminent les faits sur lesquels il peut fonder ses réponses.

## Connaissances [#connaissances]

Les sources de connaissances sont des contenus indexés, tels que des notes, des URL, des fichiers, des FAQ et des produits. Elles étayent les réponses mais ne remplacent pas les instructions de comportement. Mettez à jour la source lorsqu'un fait change.

## Canal [#canal]

Un canal est l'endroit où un visiteur discute avec l'agent : un widget intégré à votre site existant, d'anciennes pages de démonstration hébergées, la voix, Telegram, WhatsApp, Messenger, Instagram, Discord ou KakaoTalk. Les fonctionnalités varient selon le canal.

## Crédits et droits d'utilisation [#crédits-et-droits-dutilisation]

Les opérations d'IA consomment des crédits. Les minutes de voix en direct, le nombre de sites et les options de personnalisation de la marque font l'objet de droits distincts selon l'offre. Les requêtes d'API qui déclenchent un traitement d'IA utilisent les mêmes limites de compte sous-jacentes.

## État de publication [#état-de-publication]

Un lancement à partir d'une URL crée un brouillon non publié. **Afficher sur mon site web** dans **Placez-le là où sont vos clients** (ou sur la page Agent) active l'intégration sur votre site web existant ; **Vérifier mon site** confirme que le code y est bien présent. Les nouveaux agents ne disposent pas de page marketing hébergée. Les tests du propriétaire ne sont jamais mis en ligne.

L'**activation** correspond à la première conversation d'un visiteur ou au premier lead capturé, et non à un test du propriétaire.

Les modifications d'**affichage** (et du badge de marque) sont enregistrées automatiquement et mettent à jour l'intégration en direct sans nouvelle publication. Les instructions sont elles aussi enregistrées automatiquement ; les connaissances s'appliquent dès qu'une source est indexée. Le comportement des connecteurs et de l'intégration repose sur l'état publié ou configuré actuel de l'agent, comme décrit dans chaque guide de fonctionnalité.

---

# Visite du tableau de bord

Source: /fr/docs/getting-started/dashboard.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;layers&#x22;, title: &#x22;Accueil de l'espace de travail&#x22;, description: &#x22;Liste des sites, état du forfait et point d'entrée pour les nouveaux projets.&#x22; },
{ icon: &#x22;build&#x22;, title: &#x22;Commandes de l'agent&#x22;, description: &#x22;Récapitulatif de lancement, agent, affichage et paramètres d'installation pour un agent.&#x22; },
{ icon: &#x22;chart&#x22;, title: &#x22;Outils d'exploitation&#x22;, description: &#x22;Boîte de réception, analytics, diffusions, monétisation et utilisation.&#x22; },
{ icon: &#x22;code&#x22;, title: &#x22;Paramètres développeur&#x22;, description: &#x22;Clés API, webhooks, applications OAuth et identifiants d'intégration.&#x22; }
]"
/>

Le tableau de bord est organisé autour des sites. Utilisez le sélecteur de site avant de modifier du contenu, des identifiants ou des paramètres opérationnels. Le collage de l'URL d'un site web crée le premier brouillon sur l'écran de génération, et non sur cette liste d'accueil — voir [Créer un agent](/fr/docs/build/create-agent).

## Agent [#agent]

**Agent** s'ouvre sur le récapitulatif de lancement — ce qui a été examiné, où l'agent est installé, si un customer a déjà échangé avec lui, la date de fin de l'essai — avec le widget en direct à côté. Ses onglets sont **Aperçu** (instructions, état des sources, vérification des réponses et visibilité sur le site web), **Affichage** (apparence du widget ; les modifications s'enregistrent automatiquement et mettent à jour l'intégration en direct), **Voix** et **Actions**. Le menu **Mettre en ligne** contient le code d'installation du **Widget de site web** et les liens vers chaque channel de messagerie. **Connaissances** regroupe tout ce sur quoi l'agent s'appuie pour répondre. **Channels** permet de connecter les channels de messagerie. Une courte liste **Premiers pas** reste affichée jusqu'à la première conversation avec un customer.

## Site [#site]

Il n'existe pas de page Intégration distincte : le code d'installation et les **Adresses de sites web autorisées** pour un site web existant se trouvent dans **Agent → Mettre en ligne → Widget de site web**. Le commutateur **Agent link** se trouve dans l'onglet **Affichage**. Il n'existe aucune fonctionnalité de création par chat ni de génération de site. Les éventuelles pages hébergées restantes ne font pas partie du produit de création.

## Activité [#activité]

**Conversations** rassemble les fils de discussion du web et des connectors, où vous pouvez répondre en tant que personne. **Tickets** suit les demandes d'assistance. **Diffusion** envoie des messages approuvés à une audience, tandis que **Notifications** est le fil d'activité du tableau de bord pour les leads, les handoffs, les réservations, les approbations et les autres événements destinés à l'owner ; sa carte **Alertes** peut dupliquer ce fil vers Telegram. **Analytics** présente le trafic et l'engagement.

## Contrôles du compte [#contrôles-du-compte]

La section épinglée **Espace de travail** contient **Tous les agents**, **Utilisation et crédits** (crédits et limites du forfait), **Clés des fournisseurs d'IA**, **Développeur** et **Données et confidentialité**. Les clés API sont des identifiants au niveau du compte et ne doivent être créées que pour des applications de confiance.

<Callout title="Vérifier le site actif">
  Le nom du site actif s'affiche dans le sélecteur de site. Vérifiez-le avant de supprimer des sources, de renouveler des secrets de connector ou de publier.
</Callout>

---

# Démarrage rapide

Source: /fr/docs/getting-started/quickstart.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/create-agent&#x22;, label: &#x22;Créer un agent&#x22;, icon: &#x22;spark&#x22; },
{ href: &#x22;/fr/docs/build/knowledge&#x22;, label: &#x22;Ajouter des connaissances&#x22;, icon: &#x22;book&#x22; },
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: &#x22;Intégrer&#x22;, icon: &#x22;embed&#x22; },
{ href: &#x22;/fr/docs/operate/conversations&#x22;, label: &#x22;Consulter la boîte de réception&#x22;, icon: &#x22;message&#x22; }
]"
/>

Ce guide vous accompagne de la création de votre compte jusqu'à un agent opérationnel sur votre propre site web. Vous n'avez pas besoin d'écrire de code. Votre essai de 7 jours démarre dès l'inscription : sans carte bancaire, sans offre à choisir. Une URL collée sur la page d'accueil est conservée tout au long de l'inscription. `/try` permet aux visiteurs de coller une URL et de discuter avec un brouillon filigrané avant de le récupérer lors de l'inscription.

<TutorialVideo episode="ep01" />

## Avant de commencer [#avant-de-commencer]

Vous avez besoin d'un compte et de l'URL publique du site web que l'agent doit représenter. Gardez une première version ciblée : un seul produit ou une seule mission est plus facile à évaluer qu'un agent censé répondre à toutes les questions sur une entreprise.

## 1. Collez l'URL du site web [#1-collez-lurl-du-site-web]

Sur la page d'accueil de Make Agent Fast, collez l'URL et continuez. Après l'inscription ou la connexion, la même URL est conservée : on ne vous demande pas de la coller à nouveau. Il n'y a pas de constructeur de pages dans ce parcours.

Pas encore de site web ? Le premier écran accepte aussi quelques réponses écrites, ou un exemple pour voir comment cela fonctionne. Si vous avez déjà un compte, coller une URL lance tout de même un **nouveau** brouillon non publié à partir de ce site.

## 2. Patientez pendant la création du brouillon [#2-patientez-pendant-la-création-du-brouillon]

L'écran de génération indique le travail réellement effectué :

1. **Lecture du site**
2. **Création de l'agent**
3. **Test des réponses**

Cela prend généralement quelques secondes, et jusqu'à environ une minute pour un site plus volumineux. Pendant ce temps, **Trouvé jusqu'à présent** liste ce que nous avons lu : nom de l'entreprise, coordonnées, horaires, adresse, pages. Si les horaires ou l'adresse sont manquants, vous pouvez les saisir directement ici. Rien n'est encore publié.

## 3. Rencontrez votre agent [#3-rencontrez-votre-agent]

Vous arrivez sur **Rencontrez votre agent** : le vrai chat, accompagné de trois vérifications rapides : une information qu'il connaît, une information qu'il ne doit pas inventer, et une demande de mise en relation avec une personne. Appuyez sur **Poser cette question**, lisez la réponse, puis acceptez-la ou corrigez-la. Une réponse corrigée devient une connaissance que l'agent utilisera désormais. Les essais par texte consomment des crédits. Les demandes de contact et les actions sont simulées : rien n'est envoyé, réservé ni comptabilisé comme un client. La voix et les workflows de tickets sont disponibles après les essais. Si vous modifiez les connaissances ou les actions de l'agent, répétez les vérifications concernées.

Choisissez ensuite sa mission principale et les moyens par lesquels vos clients peuvent vous joindre. Les canaux de messagerie sont inclus dans l'offre Operate ; un essai Launch peut passer une fois à Operate en conservant la même date de fin.

## 4. Placez-le là où se trouvent vos clients [#4-placez-le-là-où-se-trouvent-vos-clients]

Indiquez qui l'ajoute à votre site web, enregistrez l'adresse de la page où il fonctionnera, activez-le, puis ajoutez le code d'une ligne (ou envoyez-le à votre développeur, ou demandez une installation assistée). Appuyez ensuite sur **Vérifier mon site** : nous recherchons un code d'installation valide sur votre page et vérifions que le site est autorisé. Ouvrez ensuite votre site et posez une question au widget. La confirmation manuelle est indiquée séparément ; si une nouvelle vérification échoue, vous êtes invité à réessayer. Copier le code n'est pas l'étape finale : c'est la vérification qui compte. Les nouveaux agents ne disposent pas d'une page marketing hébergée.

## 5. Activez-le avec un vrai visiteur [#5-activez-le-avec-un-vrai-visiteur]

L'activation correspond à la première conversation avec un **visiteur** ou au premier lead capturé, et non à un test du propriétaire. La page de l'agent conserve un reçu de lancement et une courte liste de démarrage tant que cela n'est pas arrivé. Consultez [Créer un agent](/fr/docs/build/create-agent) pour découvrir l'ensemble du processus.

## Étapes suivantes [#étapes-suivantes]

* [Personnaliser le widget](/fr/docs/build/appearance)
* [Intégrer l'agent](/fr/docs/embed/overview)
* [Consulter les conversations et les leads](/fr/docs/operate/conversations)

---

# Documentation

Source: /fr/docs.md

Make Agent Fast réunit en un seul endroit tout ce qu'il faut pour créer un agent client, connecter ses connaissances et aller à la rencontre de vos clients, sur le site que vous avez déjà et dans les canaux qu'ils utilisent déjà.

Un agent client pour votre entreprise, sur votre page et dans vos canaux de messagerie, qui ne répond que ce que vous avez approuvé et transmet le reste à un humain.

## Tutoriels vidéo [#tutoriels-vidéo]

<TutorialSeries />

## Pour commencer [#pour-commencer]

Choisissez un parcours selon ce que vous souhaitez mettre en place en premier.

<CardGrid>
  <DocCard href="/fr/docs/getting-started/quickstart" title="Créer votre premier agent" description="Collez l'URL d'un site web, relisez le brouillon et activez l'intégration." art="quickstart" />

  <DocCard href="/fr/docs/embed/overview" title="Ajouter un agent à votre site web" description="Installez le lanceur flottant avec une balise script ou à l'aide d'un guide dédié à votre framework ou CMS." art="embed" />

  <DocCard href="/fr/docs/connectors/overview" title="Connecter un canal" description="Répondez depuis WhatsApp, Messenger, Discord et d'autres canaux pris en charge." art="channel" />

  <DocCard href="/fr/docs/api/overview" title="Développer avec l'API" description="Automatisez les workflows liés aux agents, aux sites, aux contenus, aux conversations et aux opérations." art="api" />
</CardGrid>

## Le workflow de base [#le-workflow-de-base]

<Steps>
  <Step title="Créer">
    Collez l'URL de votre site web. Nous l'explorons et rédigeons un brouillon d'agent. Rien n'est visible par vos clients avant la dernière étape de l'onboarding.
  </Step>

  <Step title="Relire">
    Faites connaissance avec l'agent, vérifiez quelques réponses, puis placez-le là où se trouvent vos clients.
  </Step>

  <Step title="Diffuser">
    Ajoutez le code d'installation depuis 

    **Mise en ligne**

     à votre site existant, partagez l'Agent link ou connectez un canal de messagerie.
  </Step>

  <Step title="Améliorer">
    Ajoutez des connaissances, ajustez l'

    **Affichage**

     du widget, puis passez en revue les conversations et les leads.
  </Step>
</Steps>

<Callout title="Utiliser cette documentation avec un assistant IA">
  Chaque page est disponible au format Markdown. Ouvrez le menu d'actions de la page pour la copier ou la télécharger, ou envoyez son URL Markdown canonique à ChatGPT ou à Claude. L'ensemble du corpus lisible par machine est disponible à l'adresse [/docs/llms-full.txt](/fr/docs/llms-full.txt).
</Callout>

## Ce que vous pouvez créer [#ce-que-vous-pouvez-créer]

<FeatureGrid>
  <FeatureItem icon="embed" title="Intégration au site web" description="Un assistant de support ou de vente sur votre site existant, avec une seule balise script." />

  <FeatureItem icon="message" title="Agent de messagerie" description="Un seul agent qui répond à vos clients sur Telegram, WhatsApp, Messenger, Instagram, Discord ou KakaoTalk." />

  <FeatureItem icon="voice" title="Expériences vocales" description="Messages vocaux et appels en direct sur les offres compatibles." />

  <FeatureItem icon="code" title="Automatisations via l'API" description="Contrôle programmatique des sites, des connaissances, des conversations et des webhooks." />

  <FeatureItem icon="chart" title="Outils d'exploitation" description="Boîte de réception, analyses, leads, diffusions, monétisation et contrôle de l'utilisation." />

  <FeatureItem icon="site" title="Agent link" description="Une page de chat publique à l'adresse propre de votre agent, à partager là où un script ne peut pas s'exécuter. Les nouveaux agents ne disposent pas de page marketing hébergée." />
</FeatureGrid>

## Obtenir de l'aide [#obtenir-de-laide]

Si un guide ne répond pas à votre question, utilisez le contrôle de retour d'expérience en bas de la page ou contactez le support depuis votre tableau de bord. Pour connaître les limites du produit et les informations de facturation, consultez [Offres et tarifs](/fr/docs/account/pricing).

---

# Utiliser Claude, Codex, Cursor et ChatGPT

Source: /fr/docs/operate/ai-assistants.md

Connectez Make Agent Fast à un assistant IA et pilotez vos agents de service client depuis le chat que vous utilisez déjà. Demandez à l'assistant ce que les clients ont demandé cette semaine, lisez une conversation provenant de Telegram, corrigez une réponse erronée de votre agent ou créez un nouvel agent à partir d'un site web. L'assistant travaille uniquement avec l'entreprise que vous approuvez, avec les mêmes autorisations et les mêmes crédits que le tableau de bord.

<TutorialVideo episode="ep10" />

## Ce que vous pouvez demander [#ce-que-vous-pouvez-demander]

* « Liste mes agents Make Agent Fast et dis-moi lesquels ont le widget de site web activé. »
* « Affiche le rapport de cette semaine pour l'agent de ma boulangerie et les questions auxquelles il n'a pas pu répondre. »
* « Lis la dernière conversation WhatsApp et rédige une réponse. »
* « Quand un client demande une livraison à Samarcande, réponds : nous livrons le mardi et le vendredi. »
* « Crée un agent de support à partir de [https://example.com](https://example.com) en ouzbek. »
* « Quels leads sont arrivés depuis lundi ? Marque le lead du gâteau de mariage comme qualifié. »

## Connecter Claude [#connecter-claude]

1. Ouvrez [Make Agent Fast dans le répertoire de connecteurs de Claude](https://claude.ai/directory/44ae8877-eaf6-46db-a4f6-049162fead01) et sélectionnez **Connecter**. Le bouton **Connect to Claude** de la [page de configuration de l'agent](/connect) ouvre la même page. Vous pouvez aussi ouvrir **Customize → Connectors** dans Claude et rechercher **Make Agent Fast**. S'il n'apparaît pas encore pour votre compte, choisissez **Add → Add custom connector** et saisissez l'adresse du serveur ci-dessous.
2. Claude ouvre une fenêtre de connexion à Make Agent Fast. Connectez-vous ou créez un compte.
3. Choisissez l'entreprise à connecter, vérifiez les autorisations, puis sélectionnez **Autoriser l'accès**. Si l'entreprise n'a pas encore d'abonnement et que vous n'avez jamais utilisé l'essai gratuit, l'autorisation de l'accès démarre l'essai de 7 jours. Aucune carte bancaire n'est nécessaire.
4. De retour dans Claude, demandez « Liste mes agents Make Agent Fast » pour vérifier la connexion.

```text
https://makeagent.fast/api/mcp
```

Sur Claude Team et Enterprise, un propriétaire doit activer le connecteur pour l'organisation avant que les membres puissent le connecter.

Une seule connexion fonctionne dans l'application de bureau Claude, sur claude.ai et dans Claude Code connecté avec le même compte Claude. Vous pouvez également coller dans un chat Claude l'invite de configuration disponible dans **Configurez votre agent** sur la [page de configuration de l'agent](/connect) : Claude affiche le connecteur Make Agent Fast avec un bouton **Connecter**.

## Connecter ChatGPT [#connecter-chatgpt]

Le plugin Make Agent Fast pour ChatGPT est en cours de validation. En attendant sa publication, les utilisateurs de ChatGPT qui peuvent ajouter des connexions personnalisées (par exemple en mode développeur ou en tant qu'administrateurs d'espace de travail) peuvent ajouter la même adresse de serveur. La connexion, le choix de l'entreprise et les autorisations sont identiques à ceux de Claude.

## Connecter Codex ou Cursor [#connecter-codex-ou-cursor]

Le plus rapide est d'utiliser **Configurez votre agent** sur la [page de configuration de l'agent](/connect). Cela copie une invite de configuration. Collez-la dans un chat de votre application, et l'agent ajoute Make Agent Fast à votre place. Chaque application se connecte via votre navigateur ; aucune clé API n'est nécessaire.

* **Codex :** collez l'invite dans un nouveau chat Codex. Codex ajoute le serveur et ouvre la page de connexion dans votre navigateur. Approuvez l'accès, puis démarrez un nouveau chat pour que les outils soient chargés.
* **Cursor :** collez l'invite dans un chat Cursor. Cursor ajoute le serveur à `~/.cursor/mcp.json`. Ouvrez **Customize → MCPs**, sélectionnez **Authenticate** à côté de `makeagentfast`, puis approuvez l'accès.

Dans les deux cas, choisissez l'entreprise, vérifiez les autorisations et demandez « Liste mes agents Make Agent Fast ». Les autres applications compatibles avec le MCP distant et la connexion par navigateur, comme VS Code, utilisent la même adresse de serveur.

### Configurer manuellement [#configurer-manuellement]

Claude Code : ajoutez le serveur, puis saisissez `/mcp` et connectez-vous.

```bash
claude mcp add --transport http makeagentfast https://makeagent.fast/api/mcp
```

Codex : `codex mcp login` permet de vous reconnecter ultérieurement.

```bash
codex mcp add makeagentfast --url https://makeagent.fast/api/mcp
codex mcp login makeagentfast
```

Cursor : ajoutez ceci à `~/.cursor/mcp.json`, puis sélectionnez **Authenticate** dans **Customize → MCPs**.

```json
{
  "mcpServers": {
    "makeagentfast": { "url": "https://makeagent.fast/api/mcp" }
  }
}
```

VS Code : ajoutez le serveur, puis démarrez `makeagentfast` depuis la liste des serveurs MCP.

```bash
code --add-mcp '{"name":"makeagentfast","type":"http","url":"https://makeagent.fast/api/mcp"}'
```

## Ce que l'assistant peut faire [#ce-que-lassistant-peut-faire]

| Outil                                     | Fonction                                                                                          | Modifie les données |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------- | ------------------- |
| `list_agents`, `get_agent`                | Vos agents, l'état du widget, les canaux, le code d'installation et le dernier import de page web | Non                 |
| `get_report`, `list_unanswered_questions` | Conversations, leads, questions principales et questions sans réponse                             | Non                 |
| `list_conversations`, `get_conversation`  | Conversations du site web, de la voix et de chaque canal connecté                                 | Non                 |
| `list_leads`                              | Leads avec nom, e-mail et message                                                                 | Non                 |
| `create_agent_from_website`               | Crée un agent brouillon privé à partir d'un site web                                              | Oui                 |
| `create_agent_from_notes`                 | Crée un agent brouillon privé à partir de faits rédigés, pour une entreprise sans site web        | Oui                 |
| `test_agent`                              | Pose une question à votre agent sans créer de conversation client ; consomme des crédits          | Oui                 |
| `add_knowledge`, `save_answer`            | Ajoute une page web ou du texte, ou enregistre la bonne réponse à une question                    | Oui                 |
| `reply_to_customer`                       | Envoie votre réponse sur le canal de la conversation et met l'agent en pause sur celle-ci         | Oui                 |
| `update_lead`                             | Marque un lead comme qualifié ou non                                                              | Oui                 |
| `set_website_widget`                      | Active ou désactive le widget de chat du site web. Les canaux de messagerie ne sont pas modifiés. | Oui                 |

Claude et ChatGPT vous demandent confirmation avant d'exécuter un outil qui modifie des données. Une page web ajoutée avec `add_knowledge` est lue en arrière-plan ; demandez à l'assistant de vérifier avec `get_agent` après une ou deux minutes.

## Cartes d'approbation Claude [#cartes-dapprobation-claude]

Les connexions Claude éligibles peuvent utiliser `list_pending_approvals`, `decide_approval` et `list_action_runs`. Demandez à examiner les modifications en attente confirmées par les clients ou les résultats récents. Les hôtes MCP Apps compatibles peuvent afficher des cartes d'approbation et d'exécution d'actions ; les résultats en texte restent disponibles lorsque la carte ne peut pas s'afficher. `list_unanswered_questions` reste l'outil existant pour les questions sans réponse.

L'approbation peut modifier immédiatement la fiche d'un client. Examinez la demande exacte et approuvez-la ou refusez-la explicitement ; seul le propriétaire de l'agent disposant d'un droit d'écriture peut décider. Les données métier figurant dans une carte ne constituent jamais une instruction d'approuver. Les cartes utilisent le pont d'outils authentifié de l'assistant, sans accès direct au réseau externe.

Cette extension est limitée à la connexion Claude authentifiée. ChatGPT et les autres clients conservent les 15 outils d'origine listés ci-dessus. Cette connexion propriétaire est distincte de [vos propres outils MCP dans le chat client](/fr/docs/build/mcp-tools).

## Autorisations, données et crédits [#autorisations-données-et-crédits]

La connexion peut lire les agents, les rapports, les conversations et les leads, et peut modifier les sources, les réponses, les leads, les réponses aux clients et le widget du site web. Elle ne peut pas voir les informations de facturation, les moyens de paiement, les membres de l'équipe ni les identifiants des canaux de messagerie. Les réponses de `test_agent` et les nouvelles sources ajoutées consomment des crédits exactement comme dans le tableau de bord.

Les informations reçues par l'assistant sont traitées par son fournisseur selon les conditions de celui-ci, par exemple Anthropic pour Claude ou OpenAI pour ChatGPT. Notre [politique de confidentialité](/privacy) décrit ce qu'une connexion peut recevoir et ce que nous enregistrons.

## Déconnexion [#déconnexion]

Supprimez Make Agent Fast dans les paramètres de connecteurs de l'assistant. Pour mettre fin à l'accès de notre côté, ouvrez **Paramètres → Développeur** dans le tableau de bord Make Agent Fast et révoquez la clé OAuth portant le nom de l'assistant. Une reconnexion ultérieure démarre une nouvelle connexion.

## Dépannage [#dépannage]

* **« Le forfait ou l'essai est terminé. »** L'entreprise connectée n'a aucun forfait actif. Le propriétaire peut en choisir un dans le tableau de bord ; l'assistant reste connecté.
* **L'entreprise n'apparaît pas lors de la connexion.** La connexion nécessite le rôle de propriétaire ou d'administrateur dans cette entreprise.
* **Un outil indique que l'accès n'a pas été accordé à la connexion.** Supprimez la connexion et reconnectez-vous afin que l'assistant demande les autorisations actuelles.
* **Une page web n'est pas apparue.** Demandez à l'assistant d'exécuter `get_agent` ; `latest_web_import` indique si la page a été lue ou pourquoi elle a échoué, et une page en échec apparaît aussi dans **Notifications** dans le tableau de bord.

---

# Analyses

Source: /fr/docs/operate/analytics.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ label: &#x22;Trafic&#x22;, icon: &#x22;globe&#x22; },
{ label: &#x22;Engagement&#x22;, icon: &#x22;chat&#x22; },
{ label: &#x22;Résultats&#x22;, icon: &#x22;chart&#x22; },
{ label: &#x22;Canaux&#x22;, icon: &#x22;connectors&#x22; }
]"
/>

<TutorialVideo episode="ep08" />

## Définir la fenêtre de mesure [#définir-la-fenêtre-de-mesure]

Ouvrez la page **Analyses** d'un site et choisissez 7, 30 ou 90 jours, ou bien une date de début et de fin personnalisée. Sélectionnez la métrique principale, un filtre facultatif par canal ou source, puis **Comparer avec la période précédente** lorsque vous avez besoin d'une base de référence comparable.

Les filtres s'appliquent au rapport et à l'URL, ce qui permet de reproduire une vue. Pour interpréter une comparaison, utilisez des campagnes de durée équivalente et tenez compte des jours de la semaine, de la saisonnalité et de l'état de publication. Un pourcentage élevé issu d'un ou deux événements n'est pas une preuve fiable.

## Comprendre les principales métriques [#comprendre-les-principales-métriques]

| Métrique          | Signification                                                                                                             |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------- |
| **Visites**       | Pages vues publiques enregistrées, dédupliquées lorsque le modèle d'analyse peut identifier le même visiteur le même jour |
| **Conversations** | Le début d'une conversation, et non chaque message échangé                                                                |
| **Leads**         | Événements ou enregistrements de leads capturés dans le contexte sélectionné                                              |
| **Conversion**    | Ratio visite-lead ; examinez aussi les ratios visite-conversation et conversation-lead                                    |

Le volume de messages et le nombre moyen de messages par conversation sont des mesures d'engagement, et non des débuts de conversation supplémentaires. Les mesures de visiteurs récurrents, de questions sans réponse, de handoffs, de réservations et de leads qualifiés décrivent des étapes différentes du parcours.

## Lire les tendances, l'entonnoir et les horaires [#lire-les-tendances-lentonnoir-et-les-horaires]

Utilisez la tendance quotidienne pour repérer un point de rupture, puis comparez-le aux mises en production, aux campagnes, aux mises à jour des sources, aux incidents des fournisseurs et aux changements de publication. L'entonnoir sépare trois questions : les visiteurs ont-ils démarré une conversation, les conversations ont-elles généré des leads, et les visites ont-elles généré des leads au global ?

Les vues par heure et par jour de la semaine indiquent quand l'activité enregistrée a eu lieu. Elles sont utiles pour planifier les équipes et le calendrier des campagnes, mais les fuseaux horaires, la géographie de l'audience et les petits échantillons peuvent fausser une simple conclusion sur le « meilleur moment ».

## Examiner l'acquisition et les canaux [#examiner-lacquisition-et-les-canaux]

Les principales sources s'appuient sur les informations de référent et d'UTM lorsqu'elles sont disponibles. La catégorie Direct/aucune inclut le trafic dont la source est absente ou masquée. La confidentialité des navigateurs, les applications de liens, les redirections, les contrôles de consentement et les parcours multi-appareils rendent l'attribution incomplète ; n'attribuez pas de force les visites sans source à une campagne.

La performance par canal compare l'activité enregistrée en texte, en voix et en temps réel. Les conversations des connecteurs de messagerie contribuent à la vision globale de l'activité, mais toutes les plateformes externes n'exposent pas la même base de pages vues ou d'attribution ; les taux de conversion entre canaux ne sont donc pas parfaitement équivalents.

## Repérer les lacunes de connaissances et de conversations [#repérer-les-lacunes-de-connaissances-et-de-conversations]

Le tableau des questions affiche les sujets fréquemment abordés ainsi que le nombre de questions non résolues ou révélant une lacune. **Ce sur quoi votre agent s'est appuyé** présente les réponses récentes ainsi que les sources de connaissances enregistrées. Utilisez les deux avec la boîte de réception **Conversations** réelle :

1. Repérez une question à fort volume ou à forte lacune.
2. Lisez plusieurs échanges complets.
3. Déterminez si le problème vient d'un manque de connaissances, d'un conflit, de la personnalité, de la langue, de l'interface ou de l'intention du visiteur.
4. Effectuez une seule modification maîtrisée.
5. Relancez les tests d'acceptation et comparez avec une nouvelle période.

Une métrique indique où investiguer ; elle n'explique pas la cause à elle seule.

## Gérer les leads et le suivi [#gérer-les-leads-et-le-suivi]

La zone des leads affiche les leads capturés, permet d'exporter ou de supprimer en toute sécurité, et peut créer un suivi après relecture. L'attribution filtrée des leads peut s'appuyer sur des événements de leads plus récents, alors que la boîte de réception des leads affiche toujours tous les enregistrements de leads capturés ; lisez la note affichée par le tableau de bord avant de supposer que les totaux doivent correspondre exactement.

## Exporter le rapport [#exporter-le-rapport]

Utilisez **Exporter** pour créer un fichier Markdown (`.md`), Excel (`.xlsx`) ou une vue d'impression/PDF correspondant aux filtres actuels. L'option PDF ouvre une page optimisée pour l'impression ; choisissez **Enregistrer au format PDF** dans le navigateur. Conservez le contexte des filtres et des dates avec le fichier exporté et protégez toutes les données de visiteurs ou de leads qu'il contient.

Les exports sont des instantanés. Ils ne sont plus mis à jour et ne doivent pas être considérés comme une source de vérité distincte une fois que les filtres du tableau de bord ou les événements sous-jacents ont changé.

## Confidentialité et qualité des données [#confidentialité-et-qualité-des-données]

Ne collectez que les données d'analyse nécessaires à une finalité définie et reflétez le suivi concerné dans les informations destinées aux visiteurs. Le blocage par consentement, les contrôles de confidentialité, la livraison hors ligne, la suppression des doublons, les lacunes des fournisseurs et les événements plus anciens peuvent tous produire des données incomplètes. Utilisez l'horodatage du dernier événement affiché dans le tableau de bord pour distinguer « zéro » de « aucun événement reçu récemment ».

## Dépannage [#dépannage]

| Symptôme                                                            | Vérification                                                                                                |
| ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| Le rapport est vide                                                 | Site, dates et filtres corrects, trafic publié, dernier événement, blocage par consentement et test public  |
| Les nombres de visites/conversations diffèrent de ceux des messages | Comportement normal ; les débuts et les vues sont dédupliqués différemment des messages échangés            |
| Les leads filtrés diffèrent du total de la boîte de réception       | Attribution filtrée par événements par rapport à tous les enregistrements de leads stockés                  |
| La source est Direct/aucune                                         | Référent ou UTM manquant ou masqué ; reproduisez avec un lien public balisé                                 |
| L'export diffère de l'écran                                         | Mêmes filtres et mêmes dates au moment de l'export, et vérifiez si les données en direct ont changé ensuite |

## Conversion et résultats commerciaux [#conversion-et-résultats-commerciaux]

L'entonnoir du site suit désormais dans l'ordre les événements enregistrés **visite → conversation → lead**, pour le même visiteur le même jour UTC. Chaque étape affiche les volumes, la conversion par rapport à l'étape précédente et l'abandon observé. Le temps médian mesure le délai entre la visite et la finalisation du lead. Les plages prédéfinies couvrent des jours calendaires UTC, y compris aujourd'hui ; la journée en cours est incomplète.

Survolez le graphique de tendance, touchez-le ou utilisez les touches fléchées pour consulter les valeurs quotidiennes exactes. La vue de conversion trace un pourcentage issu de l'entonnoir ordonné du site. Développez **Afficher les données quotidiennes** pour accéder à un tableau accessible. Les en-têtes du tableau des sources permettent de trier par volume ou par conversion ; sélectionner une source applique le filtre dans l'URL.

**Qualification des leads** affiche l'état actuel des leads créés pendant la période sélectionnée. **Résultats des paiements** affiche les statuts des paiements natifs et les montants encaissés par devise, hors paiements de test. Les commandes externes nécessitent une intégration vérifiée ; l'absence de paiements enregistrés ne prouve pas l'absence de ventes. Les opportunités commerciales existantes apparaissent selon leur étape actuelle, avec les motifs de perte saisis par l'équipe. Ces panneaux utilisent la plage de dates pour toutes les sources et tous les modes.

**Canaux de communication** distingue les plateformes réelles : web, voix et messagerie. Cette vue comptabilise les conversations actives, les messages entrants, les réponses de l'agent et les réponses humaines. Une réponse n'est pas une résolution. Les liens vers la boîte de réception ouvrent l'historique du canal avec ses propres filtres. Tous les nouveaux tableaux sont inclus dans les exports du rapport.

---

# Diffusions

Source: /fr/docs/operate/broadcasts.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Destinataires&#x22;, icon: &#x22;account&#x22; }, { label: &#x22;Modèle&#x22;, icon: &#x22;message&#x22; }, { label: &#x22;File d'attente&#x22;, icon: &#x22;bolt&#x22; }]" />

<TutorialVideo episode="ep07" start="146" />

## Connaître le périmètre actuel [#connaître-le-périmètre-actuel]

La fonctionnalité de diffusion du tableau de bord cible actuellement **Kakao AlimTalk**. Il ne s'agit pas d'un outil général de création de campagnes pour Telegram, WhatsApp, Messenger ou Discord. Une passerelle AlimTalk en production nécessite un profil d'expéditeur enregistré, un modèle approuvé, un prestataire de plateforme configuré et un numéro de téléphone coréen joignable pour chaque destinataire.

Le nombre de destinataires est calculé à partir des leads non effacés du site actuel disposant d'une coordonnée joignable, dédoublonnés par coordonnée. Le mode développement/simulation peut accepter un e-mail de secours, mais une véritable passerelle AlimTalk exige un numéro de téléphone approprié. Vérifiez que le mode affiché est bien « live » avant de considérer un message mis en file d'attente comme une réelle livraison.

## Comprendre la limite de l'envoi [#comprendre-la-limite-de-lenvoi]

Sélectionner **Envoyer** met en file d'attente une tâche durable pour chaque destinataire actuellement éligible. Le tableau de bord ne propose actuellement ni segmentation par envoi, ni modification des destinataires, ni heure programmée, ni aperçu de l'audience, ni pause, ni rappel. N'utilisez pas ce bouton avant d'être certain que l'ensemble de l'audience résolue est visé et autorisé à recevoir le message.

Le formulaire accepte un code de modèle approuvé et un corps de message de 2 000 caractères maximum. Un prestataire peut imposer un modèle plus court, une formulation et des variables approuvées à l'identique, ainsi que des limites de calendrier, de profil d'expéditeur et de politique. La mise en file d'attente par Make Agent Fast ne contourne pas ces règles.

## Préparer une diffusion conforme [#préparer-une-diffusion-conforme]

1. Vérifiez que le parcours de capture de leads du site a bien demandé la coordonnée concernée ainsi que le consentement ou la base légale applicable.
2. Retirez ou effacez les personnes qui ne doivent pas être contactées avant de résoudre l'audience.
3. Vérifiez qu'un prestataire AlimTalk en production et une clé d'expéditeur enregistrée sont configurés.
4. Obtenez le code de modèle approuvé par le prestataire et faites correspondre le corps du message à ce modèle.
5. Vérifiez l'identité de l'expéditeur, la finalité, les liens, les mentions obligatoires et le moyen de désinscription.
6. Utilisez un site/une audience de test distinct si vous avez besoin d'un petit test en production ; l'outil de composition actuel cible tous les leads éligibles de son site.

N'envoyez pas d'identifiants, de détails sensibles de compte, de dossiers protégés, de personnalisation inventée ni d'offre non approuvée par l'agent ou le site.

## Mettre en file d'attente et suivre [#mettre-en-file-dattente-et-suivre]

Après l'envoi, l'historique affiche le corps du message, le statut, le nombre de destinataires visés et le nombre d'envois réussis. Les tâches sont idempotentes par diffusion et par lead : une nouvelle tentative de la file d'attente ne devrait donc pas créer volontairement une seconde copie du même couple diffusion/destinataire.

« Envoyé » signifie que la passerelle configurée a accepté tous les envois suivis. Cela ne prouve ni la remise sur le téléphone, ni la lecture, ni la conversion, ni la validité d'un consentement marketing. Utilisez les accusés de réception de la passerelle et les rapports de votre activité lorsqu'ils sont disponibles.

Si certaines tâches échouent, la diffusion conserve la dernière erreur du prestataire, tandis que les envois réussis sont comptabilisés indépendamment. Ne créez pas de nouvelle diffusion identique avant d'avoir compris si le prestataire a accepté des tentatives antérieures.

## Automatisation via l'API [#automatisation-via-lapi]

Utilisez `broadcasts:write` pour créer un brouillon et le mettre en file d'attente via l'API publique depuis un serveur de confiance. Préservez l'idempotence et vérifiez la résolution des destinataires ainsi que l'état de préparation du prestataire. L'API ne peut pas rendre conforme un modèle AlimTalk non approuvé.

## Dépannage [#dépannage]

| Symptôme                                                      | À vérifier                                                                                                                     |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
| Le bouton Envoyer est désactivé                               | Aucun lead éligible du site avec une coordonnée joignable                                                                      |
| Le mode affiche local/dev                                     | Le prestataire AlimTalk en production ou ses identifiants ne sont pas configurés ; aucune livraison réelle aux customers       |
| La passerelle rejette le modèle                               | Code de modèle approuvé, corps/variables, profil d'expéditeur et format du destinataire                                        |
| Le nombre de destinataires inclut une coordonnée inutilisable | Une livraison réelle nécessite un téléphone ; nettoyez la capture de leads/les données avant l'envoi                           |
| L'historique reste sur « en cours d'envoi »                   | Erreur de file d'attente/du prestataire et `sent count` par rapport au nombre de destinataires                                 |
| Besoin de contacter uniquement un segment                     | Non pris en charge actuellement dans cet outil ; créez un workflow d'audience distinct et approuvé plutôt que d'envoyer à tous |

Arrêtez les envois dès que des plaintes, des destinataires inattendus, une non-concordance de modèle ou des erreurs du prestataire apparaissent.

---

# Conversations et leads

Source: /fr/docs/operate/conversations.md

{/* docs-visuals */}

<DocsIconList
  items="[
{ icon: &#x22;message&#x22;, title: &#x22;Fils unifiés&#x22;, description: &#x22;Les historiques du web, de la voix, du temps réel et des connecteurs apparaissent dans une seule boîte de réception où vous pouvez intervenir et répondre.&#x22; },
{ icon: &#x22;book&#x22;, title: &#x22;Ancrage dans les sources&#x22;, description: &#x22;Les messages de l'assistant affichent les citations de sources enregistrées lorsqu'elles sont disponibles.&#x22; },
{ icon: &#x22;account&#x22;, title: &#x22;Leads&#x22;, description: &#x22;Les noms, e-mails et intentions capturés permettent un suivi réfléchi.&#x22; }
]"
/>

<TutorialVideo episode="ep06" />

## Consulter la boîte de réception unifiée [#consulter-la-boîte-de-réception-unifiée]

Ouvrez la page **Conversations** d'un agent pour voir les 30 fils les plus récents parmi le chat web hébergé ou intégré, les messages vocaux, les transcriptions d'appels en direct, Telegram, WhatsApp, Messenger, Instagram, Discord et KakaoTalk. Utilisez **Charger plus** pour remonter dans le temps selon la date de dernière activité.

Chaque ligne indique le canal, la meilleure identité disponible du visiteur, un aperçu du dernier message, le nombre de messages et la dernière activité. Ouvrez une ligne pour lire la transcription complète enregistrée, avec les horodatages. Les bulles de l'assistant peuvent afficher la source de connaissances et la section enregistrées pour une réponse appuyée sur des sources.

Vous pouvez aussi intervenir dans une conversation. Sur la page d'un fil, **Répondre en tant que personne** vous permet d'écrire au visiteur, puis de sélectionner **Envoyer la réponse**. Répondre met l'agent en pause pendant 30 minutes afin qu'il n'intervienne pas ; **Mettre l'agent en pause 30 min** le met en pause sans réponse, et **Reprendre l'agent** lui rend la conversation plus tôt. La pause prend aussi fin d'elle-même. Les réponses du propriétaire fonctionnent pour les chats du site web et pour les chats Telegram, WhatsApp, Messenger et Instagram ; les réponses sur les messageries sont mises en file d'attente et envoyées par le canal. Il n'est pas possible de répondre depuis le tableau de bord aux conversations Discord, KakaoTalk, aux chats invités Telegram ni aux transcriptions d'appels en direct : répondez dans l'application de messagerie d'origine. Les mêmes actions sont disponibles pour l'API publique avec `conversations:write`.

## Comprendre les limites d'identité [#comprendre-les-limites-didentité]

Le web, la voix en direct et chaque connecteur utilisent des identifiants de visiteur différents. Un utilisateur Telegram, un visiteur de navigateur et un numéro WhatsApp sont des identités distinctes, sauf si vous disposez de données de rapprochement explicites et consenties. Des noms d'affichage similaires ne prouvent pas que deux fils appartiennent à la même personne.

Les libellés des connecteurs peuvent identifier le bot, la Page ou l'application plutôt que le visiteur lorsque la plateforme externe ne fournit pas d'identité d'affichage sûre. Considérez les identifiants de canal et les noms déduits comme des métadonnées non fiables, et non comme une autorisation.

## Évaluer la qualité des réponses [#évaluer-la-qualité-des-réponses]

Pour un fil représentatif :

1. Lisez la question du visiteur dans son contexte plutôt que de juger uniquement la dernière réponse.
2. Vérifiez que la réponse respecte les limites de persona et de langue.
3. Examinez les sources d'ancrage affichées et comparez-les à la version actuelle des connaissances.
4. Repérez les questions sans réponse, répétées, trompeuses ou les relances inutiles.
5. Ajoutez un fait manquant validé aux connaissances ou à la FAQ, puis testez-le dans une nouvelle conversation.

Les messages passés ne sont pas réécrits lorsqu'une source de connaissances change. Démarrez un nouveau fil pour les tests de régression après une mise à jour.

## Capturer et gérer les leads [#capturer-et-gérer-les-leads]

La capture de leads peut enregistrer le nom, l'e-mail et la demande formulée d'un visiteur lorsque le flux de l'agent le permet. Les leads récents apparaissent dans **Analytique**, où un propriétaire peut générer et envoyer un suivi approuvé, exporter les données des leads ou supprimer un lead individuel.

Ne demandez que les informations nécessaires à la finalité déclarée. Une question sur un produit ou un message dans le chat ne crée pas automatiquement un consentement marketing. Avant tout suivi, confirmez le canal, la finalité, la juridiction et les exigences de désinscription applicables.

Le texte de suivi généré est un brouillon. Vérifiez le destinataire, les affirmations, les liens, les tarifs, le ton et les données personnelles avant l'envoi. Ne laissez jamais l'agent inventer une offre ou une promesse absente des connaissances de référence.

## Exporter et supprimer en toute sécurité [#exporter-et-supprimer-en-toute-sécurité]

L'export des leads crée une copie en aval placée sous votre contrôle. Stockez-la uniquement dans des systèmes approuvés, restreignez l'accès et intégrez-la à vos procédures de conservation et de suppression. Supprimer un lead retire cet enregistrement de lead, mais peut ne pas effacer une conversation associée, un message du fournisseur, un export antérieur, une notification ou un enregistrement de facturation conservé légalement.

Déconnecter une intégration ou un connecteur n'efface pas non plus automatiquement ses fils historiques. Suivez le processus de confidentialité du compte lorsqu'un visiteur fait une demande de suppression ou d'accès, et supprimez également les copies en aval.

## Routine de revue opérationnelle [#routine-de-revue-opérationnelle]

* Chaque jour pendant le lancement : examinez les nouveaux fils, les handoffs, les échecs de fournisseur et les réponses à haut risque.
* Chaque semaine : regroupez les questions récurrentes, identifiez les lacunes dans les connaissances et vérifiez l'état du suivi des leads.
* Après des changements de contenu ou de modèle : relancez le jeu de tests d'acceptation et examinez les citations.
* Après un incident : conservez les horodatages et identifiants non sensibles, isolez le canal concerné et évitez de diffuser les transcriptions privées brutes.

## Dépannage [#dépannage]

| Symptôme                             | Vérification                                                                                                                          |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
| Un fil attendu est absent            | Site correct, livraison du canal, dernier événement du connecteur, fin du test public et heure d'activité                             |
| Le fil s'ouvre avec moins d'échanges | La source était-elle une transcription en direct, un historique de connecteur ou une identité de visiteur/canal différente ?          |
| Une citation est manquante           | La réponse n'a peut-être pas utilisé de connaissances récupérables, ou d'anciens enregistrements n'ont pas de métadonnées de citation |
| La même personne apparaît deux fois  | Normal entre des identifiants de navigateur ou de canal distincts ; ne fusionnez pas sur le seul nom                                  |
| Suivi indisponible                   | E-mail ou contact du lead, état d'accès, configuration d'envoi, limites de débit et exigences de validation par le propriétaire       |

---

# Monétisation

Source: /fr/docs/operate/monetization.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Offres&#x22;, icon: &#x22;layers&#x22; }, { label: &#x22;Paiement&#x22;, icon: &#x22;bolt&#x22; }, { label: &#x22;Commandes&#x22;, icon: &#x22;chart&#x22; }]" />

## Comprendre les deux relations de facturation [#comprendre-les-deux-relations-de-facturation]

**Monétisation** permet au propriétaire d'un site de vendre une offre à un visiteur. Cette fonctionnalité est distincte de l'abonnement Make Agent Fast du propriétaire et de ses packs de crédits. Les revenus et commandes du créateur, d'une part, et l'utilisation de la plateforme par le propriétaire, d'autre part, doivent être rapprochés séparément.

La page affiche le mode de paiement en cours. **Polar (paiements réels)** peut accepter des achats réels configurés. **Local/dev (mode test)** correspond à un comportement de développement et ne doit jamais être présenté comme un paiement réglé en production.

## Créer une offre [#créer-une-offre]

Choisissez l'un des types pris en charge :

| Type                             | Usage prévu                                           |
| -------------------------------- | ----------------------------------------------------- |
| **Accès payant**                 | Débloquer une expérience d'agent réservée aux membres |
| **Appel/consultation payant(e)** | Vendre une consultation ou un appel                   |
| **Pourboire**                    | Soutien à prix fixe ou à prix libre                   |
| **Bien numérique**               | Vendre un livrable ou un accès numérique défini       |

Saisissez un titre précis, une description, le prix en centimes, la devise et, si besoin, une clé de produit Polar. Cette clé associe l'offre à un produit configuré chez le prestataire de paiement. Une offre active peut être affichée ou recommandée dans la conversation avec l'agent ; une offre inactive reste visible par le propriétaire, mais ne doit pas être vendue.

Utilisez une source de référence unique pour le prix, la livraison, la disponibilité, les conditions de remboursement, le traitement fiscal et le support. Ajoutez ces informations validées aux connaissances : l'agent ne doit inventer ni remise, ni garantie, ni délai de livraison, ni argument de rareté.

## Réserver l'agent à l'accès payant [#réserver-lagent-à-laccès-payant]

Créez et activez d'abord une offre **Accès payant**, puis sélectionnez-la sous **Agent réservé aux membres**. Les visiteurs qui ne l'ont pas débloquée se voient proposer un parcours d'achat ou de déblocage au lieu de l'accès normal au chat. Seuls les produits d'accès actifs peuvent être sélectionnés ; en outre, si l'offre sélectionnée disparaît, le système laisse l'accès ouvert (« fail open ») plutôt que de bloquer définitivement le chat.

Avant le lancement, testez les cas suivants : visiteur déconnecté ou nouveau, paiement réussi, retour d'un visiteur ayant accès, paiement annulé, événement du prestataire en double, offre inactive, et remboursement ou révocation de l'accès.

## Configurer les modes de paiement [#configurer-les-modes-de-paiement]

Pour un paiement Polar en conditions réelles, le déploiement de la plateforme et l'association des produits doivent être configurés. Une option facultative de paiement coréen peut proposer KakaoPay, Naver Pay ou Toss pour les offres en KRW, uniquement lorsque la plateforme indique que ce mode est disponible ; activer une option indisponible ne crée aucune intégration avec un prestataire.

Utilisez le mode test du prestataire lorsqu'il est disponible, puis vérifiez un petit achat réel conformément à votre politique opérationnelle. Vérifiez les sous-unités de la devise : pour l'USD, `2500` correspond à `$25.00`. Ne devinez pas le comportement des centimes pour une devise dont les conventions de sous-unités diffèrent.

## Consulter les commandes et les revenus [#consulter-les-commandes-et-les-revenus]

La page indique le nombre de commandes payées, le cumul des revenus et les achats récents. « Payé » reflète l'état de paiement enregistré auprès du prestataire ; rapprochez les frais du prestataire, les taxes, les remboursements, les rétrofacturations, les versements et la livraison dans le système financier approprié.

La suppression d'une offre n'efface pas l'historique des commandes ni de la facturation. Il est plus prudent de désactiver une offre que de la supprimer lorsqu'un opérateur a besoin de la configuration existante pour mener une enquête.

## Tarification au résultat (facultative) [#tarification-au-résultat-facultative]

**Paiement au résultat** peut déduire un montant fixe de crédits du portefeuille du propriétaire pour un lead qualifié par l'agent ou pour une demande de réservation qu'un humain confirme ensuite, en plus de l'utilisation normale. Il ne s'agit pas d'un paiement visiteur et cela ne devient pas un revenu du créateur. La qualification par l'agent ne vaut pas acceptation commerciale par un humain, et une demande de réservation n'est pas un rendez-vous confirmé. Laissez ce mode désactivé tant que le propriétaire n'a pas compris le coût supplémentaire en crédits et les définitions exactes des événements.

## Liste de contrôle avant lancement [#liste-de-contrôle-avant-lancement]

* Le mode de paiement réel ou test est clairement identifiable.
* Le titre, la description, la devise et le prix de l'offre correspondent au produit du prestataire.
* La livraison, la durée d'accès, les remboursements, les taxes, le support et la confidentialité sont documentés.
* Les connaissances de l'agent ne contiennent que des affirmations commerciales validées.
* Les parcours de réussite, d'annulation, de doublon, de remboursement et d'offre inactive ont été testés.
* Les alertes d'achat, le responsable de la livraison, le rapprochement comptable et le processus de gestion des incidents sont attribués.

## Dépannage [#dépannage]

| Symptôme                                                  | Vérification                                                                                                              |
| --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| L'offre n'apparaît pas                                    | Elle est active, pertinente pour la conversation, et l'état du site est à jour                                            |
| Paiement réel indisponible                                | Configuration des paiements du déploiement et clé de produit du prestataire de l'offre                                    |
| L'accès reste verrouillé après le paiement                | État de l'achat enregistré, visiteur/session corrects, webhook du prestataire et ID de l'offre                            |
| L'option de paiement coréen n'a aucun effet               | Le mode de paiement de la plateforme n'est pas configuré ou disponible, ou la devise de l'offre n'est pas prise en charge |
| Les revenus diffèrent du versement                        | Frais du prestataire, remboursements, rétrofacturations, taxes, délai de règlement et devise                              |
| Les crédits du propriétaire diminuent après des résultats | La tarification au résultat est activée en plus de l'utilisation normale                                                  |

---

# Notifications

Source: /fr/docs/operate/notifications.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Lead&#x22;, icon: &#x22;account&#x22; }, { label: &#x22;Handoff&#x22;, icon: &#x22;message&#x22; }, { label: &#x22;Réservation&#x22;, icon: &#x22;bolt&#x22; }]" />

<TutorialVideo episode="ep06" start="95" />

## Ce qui apparaît ici [#ce-qui-apparaît-ici]

La page **Notifications** de l'agent est un fil d'événements intégré au tableau de bord. Elle enregistre les types d'événements suivants, destinés au propriétaire :

| Type                                          | Signification                                                             |
| --------------------------------------------- | ------------------------------------------------------------------------- |
| **Nouvelle demande client** (lead)            | L'agent a enregistré les coordonnées ou l'intention d'un visiteur         |
| **Le visiteur a demandé un humain** (handoff) | La conversation a demandé ou déclenché un suivi par un humain             |
| **Le visiteur a écrit pendant votre réponse** | Un visiteur a écrit alors que vous aviez pris la main sur la conversation |
| **Nouvelle réservation**                      | Le résultat d'une réservation a été enregistré                            |
| **Ticket de support**                         | Un ticket de support a été ouvert ou mis à jour                           |
| **Action en attente d'approbation**           | Une modification confirmée par le client attend votre approbation         |
| **Action à vérifier**                         | Une action approuvée n'a pas pu être menée à bien                         |
| **Connecteur à vérifier**                     | Un canal de messagerie nécessite votre attention                          |
| **Délai de réponse SLA échu**                 | Un délai de réponse commerciale arrive à échéance                         |
| **Demande de conciergerie**                   | Vous avez demandé à la plateforme de connecter un canal pour vous         |
| **Impossible d'ajouter la page web**          | Une page qu'un assistant IA a demandé d'ajouter n'a pas pu être lue       |

Chaque élément peut afficher le type d'événement, l'heure de création, le nom ou l'adresse e-mail du visiteur lorsqu'ils sont disponibles, ainsi qu'un court extrait. Un élément non lu est mis en évidence visuellement et compte dans le nombre de notifications non lues.

La carte **Alertes** de cette page peut répliquer le fil sur Telegram : sélectionnez **M'envoyer des alertes sur Telegram** et chaque nouvelle notification arrivera aussi sous forme de message de votre propre bot Telegram connecté (ou du bot d'alertes Make Agent Fast). Les alertes d'approbation comportent les boutons **Approuver** et **Refuser**. Les alertes sont désactivées par défaut ; le fil du tableau de bord et l'e-mail adressé au propriétaire continuent de fonctionner dans tous les cas. Marquer un élément comme lu n'envoie pas d'e-mail à un visiteur, ne répond pas via un connecteur, ne modifie aucun lead et ne désabonne personne auprès d'un fournisseur externe.

## Consulter et marquer les événements [#consulter-et-marquer-les-événements]

1. Ouvrez **Notifications** pour le site concerné.
2. Traitez en priorité les handoffs et les réservations urgentes.
3. Ouvrez le contexte associé dans **Conversations** ou **Analytique** lorsque l'identité et l'intention doivent être confirmées.
4. Sélectionnez **Marquer comme lu** uniquement après que le propriétaire responsable a effectué le tri.
5. Utilisez **Tout marquer comme lu** uniquement lorsque tous les événements visibles ou non lus ont été volontairement examinés.
6. Sélectionnez **Charger plus** pour afficher les pages plus anciennes.

L'état de lecture est une aide au flux de travail du propriétaire, et non une preuve qu'un visiteur a reçu un suivi. Suivez le suivi réel dans le système de référence approuvé.

## Protéger les données des visiteurs [#protéger-les-données-des-visiteurs]

Les noms, adresses e-mail, éléments de contexte de réservation et extraits peuvent contenir des données personnelles. Limitez l'accès au tableau de bord, évitez de copier les événements dans des salons de discussion largement accessibles et ne considérez pas l'extrait comme le dossier complet du consentement ou du contexte.

Supprimer une notification ou la marquer comme lue ne supprime pas automatiquement le lead, la conversation, la réservation, l'enregistrement chez le fournisseur ou la copie exportée associés. Utilisez le processus de confidentialité et de suppression pour les demandes des personnes concernées.

## Dépannage [#dépannage]

| Symptôme                                            | À vérifier                                                                                                                           |
| --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| Un événement attendu est absent                     | Le bon site, l'aboutissement effectif du lead, du handoff ou de la réservation, l'heure de l'événement et la conversation associée   |
| Le nombre de notifications non lues semble obsolète | Actualisez la page après l'action de marquage et vérifiez qu'elle a bien réussi                                                      |
| Marquer comme lu n'a pas contacté le visiteur       | Comportement normal ; ce fil n'envoie aucun suivi                                                                                    |
| Un élément plus ancien est introuvable              | Utilisez **Charger plus** ; la première page est volontairement limitée                                                              |
| Besoin d'alertes en dehors du tableau de bord       | Activez Telegram dans la carte **Alertes** ; pour un routage de type e-mail ou Slack, utilisez l'API publique ou les webhooks signés |

Pour l'automatisation, utilisez les ressources prises en charge de l'API publique ou les événements de webhook signés plutôt que d'extraire les données de ce tableau de bord.

---

# Crédits et utilisation

Source: /fr/docs/operate/usage.md

{/* docs-visuals */}

<DocsChipRow items="[{ label: &#x22;Crédits&#x22;, icon: &#x22;layers&#x22; }, { label: &#x22;Minutes vocales&#x22;, icon: &#x22;voice&#x22; }, { label: &#x22;Recharges&#x22;, icon: &#x22;bolt&#x22; }]" />

<TutorialVideo episode="ep08" start="157" />

## Consulter la page d'utilisation [#consulter-la-page-dutilisation]

La section d'utilisation du tableau de bord réunit le contexte de facturation et les ressources susceptibles de bloquer une opération : offre en cours, solde de crédits, quota de sites, minutes vocales en direct, choix de recharge et actions de facturation. Consultez-la avant un lancement et après l'ajout d'une intégration à fort volume, d'un connector ou d'un client API.

N'interprétez pas un chiffre isolé comme un quota universel. Chaque droit d'utilisation protège une ressource différente.

## Distinguer les soldes et les limites [#distinguer-les-soldes-et-les-limites]

| Ressource                 | Réinitialisation ou expiration                      | Que se passe-t-il à la limite ?                                                |
| ------------------------- | --------------------------------------------------- | ------------------------------------------------------------------------------ |
| Crédits IA mensuels       | Reportés sur un cycle supplémentaire, puis expirent | Les actions IA, de connaissances ou vocales mesurées peuvent être rejetées     |
| Crédits achetés           | N'expirent pas tant qu'un abonnement est actif      | Continuent de financer les opérations mesurées tant que l'accès reste actif    |
| Nombre de sites           | Droit lié à l'offre                                 | La création d'un site supplémentaire est bloquée                               |
| Minutes vocales en direct | Quota mensuel de l'offre                            | Les sessions en temps réel nouvelles ou en cours sont limitées ou interrompues |
| Requêtes API              | Par clé API et par minute                           | La requête renvoie `429` avec des en-têtes de nouvelle tentative               |

Les crédits n'achètent ni débit API supplémentaire, ni sites, ni minutes en direct. Un droit d'utilisation ne garantit pas que le chemin de crédits ou de fournisseur nécessaire à l'opération soit disponible.

## Ce qui consomme des crédits [#ce-qui-consomme-des-crédits]

Les opérations mesurées peuvent inclure la génération de sites ou d'agents, les réponses normales de l'agent, les embeddings des connaissances, la transcription de médias, la synthèse vocale et la voix des connectors. Le coût varie selon le fournisseur, le modèle, la longueur du prompt et du contexte, la longueur de la sortie, la durée audio et le type d'opération. Un « message » n'a donc pas de prix fixe universel en crédits.

Les actions d'aperçu et de test de l'owner peuvent consommer de vraies ressources lorsqu'elles font appel à des fournisseurs en production. Utilisez des tests d'acceptation courts et représentatifs, et évitez d'indexer plusieurs fois la même source volumineuse pendant que vous déboguez un problème sans rapport.

## Consulter l'historique d'utilisation [#consulter-lhistorique-dutilisation]

**Historique d'utilisation** affiche les crédits réellement consommés, au montant final, pour chaque opération terminée. Les blocages d'autorisation temporaires, les règlements de réserve et les remboursements restent des détails de comptabilité interne et n'apparaissent pas comme des lignes distinctes côté client. Les très petites opérations d'embedding s'affichent sous la forme `<0.001` plutôt que d'être arrondies à zéro.

**Autres mouvements de solde** est un tableau distinct pour les attributions de crédits de l'offre, les recharges, les expirations et les ajustements manuels. Il ne duplique pas l'utilisation normale de l'IA. Tant qu'une opération est en cours, le solde disponible peut refléter temporairement un blocage avant que la ligne d'utilisation finale n'apparaisse ou qu'une opération échouée ne soit libérée ; actualisez la page une fois l'opération terminée lorsque vous rapprochez une action tout juste achevée.

## Crédits mensuels et crédits achetés [#crédits-mensuels-et-crédits-achetés]

Le quota mensuel dépend de l'offre active. Les crédits mensuels inutilisés sont reportés sur un cycle supplémentaire, puis expirent. Les packs ponctuels ajoutent 1 000 crédits pour 8 $, 5 000 pour 35 $ ou 15 000 pour 90 $ ; les crédits achetés n'expirent pas tant qu'un abonnement est actif.

L'achat d'un pack ne rétablit pas un abonnement à la plateforme annulé ou expiré. Lorsque le tableau de bord signale un problème de droit d'utilisation et pas seulement un solde bas, réglez d'abord l'accès et la facturation.

## Recharge automatique [#recharge-automatique]

La recharge automatique n'est disponible qu'une fois le prélèvement automatique par carte activé pour Make Agent Fast ; d'ici là, la page indique qu'elle n'est pas disponible. Lorsqu'elle est proposée, elle achète un pack de crédits à votre place quand le solde tombe sous un seuil que vous choisissez. Activez-la dans **Utilisation et crédits → Recharge automatique** : choisissez le seuil (entre 50 et 5 000 crédits) et le pack à acheter. Le prélèvement s'effectue sur la carte déjà enregistrée auprès du prestataire de paiement ; ajoutez ou modifiez cette carte via le lien du portail client situé à côté du formulaire.

Les garde-fous sont volontaires. Un seul achat est traité à la fois, et pendant son règlement la page indique qu'un achat est en cours. Au maximum trois achats automatiques ont lieu par jour. Les crédits apparaissent lorsque le paiement est réglé, et non lorsque le prélèvement démarre. Si la carte est refusée, aucun crédit n'est ajouté, la page affiche la dernière erreur et un e-mail est envoyé ce jour-là pour expliquer ce qu'il faut corriger ; le prélèvement n'est pas retenté tant que le moyen de paiement ne fonctionne pas.

La recharge automatique n'est disponible que lorsque le prélèvement hors session est activé et qu'une carte est enregistrée. Lorsqu'elle est indisponible, la page l'indique au lieu d'afficher un interrupteur sans effet.

## Modules complémentaires [#modules-complémentaires]

Les modules complémentaires ne peuvent être achetés que lorsqu'ils sont proposés à la vente : un module proposé apparaît sous **Utilisation et crédits → Modules complémentaires**, et la carte est masquée lorsqu'aucun n'est proposé. Un module que vous payez déjà reste toujours listé afin que vous puissiez l'annuler. Les modules proposés ajoutent de la capacité à l'offre actuelle, sont facturés mensuellement et peuvent être annulés à tout moment.

| Module complémentaire | Prix lorsqu'il est proposé | Remarques                                                                                        |
| --------------------- | -------------------------- | ------------------------------------------------------------------------------------------------ |
| Agent supplémentaire  | 10 $ par agent et par mois | Vous pouvez en acheter plusieurs ; chacun ajoute un seul emplacement d'agent. Inclus dans Scale. |
| Retirer le badge      | 9 $ par mois               | Masque « Made with Make Agent Fast » sur le widget. Inclus dans Operate et Scale.                |

Un module complémentaire est un abonnement distinct de l'offre : annuler le module n'affecte donc pas l'offre, et annuler l'offre ne conserve pas discrètement le module. Un module annulé reste actif jusqu'à la fin de la période déjà payée. Seul le propriétaire de la facturation peut en acheter ou en annuler un.

## Comptabilisation de la voix en direct [#comptabilisation-de-la-voix-en-direct]

Operate inclut 30 minutes en direct par mois et Scale en inclut 90. Chaque appel dispose en outre d'une limite de durée automatique configurée par l'owner, de 30 secondes à 20 minutes. Lorsqu'un jeton d'appel en direct est émis, le portefeuille est débité à l'avance de la durée maximale autorisée par le serveur, dans la limite du quota mensuel restant. Cette même durée est réservée sur le quota de minutes en direct afin que des appels simultanés ne puissent pas le dépasser.

Le flux média en direct circule directement entre le navigateur et le fournisseur temps réel ; le serveur ne peut donc pas vérifier de manière indépendante une durée plus courte déclarée par le client. Le temps non utilisé n'est donc pas remboursé partiellement une fois le jeton remis ; une session abandonnée ou non signalée est facturée à sa limite autorisée. Un échec côté serveur avant la remise du jeton libère le débit. Terminez les appels proprement pour fermer la session rapidement, mais anticipez les crédits en vous basant sur la limite d'appel configurée plutôt que sur la durée de conversation prévue de l'appelant.

Les messages vocaux sont différents : ils consomment du travail mesuré de transcription, de modèle et de synthèse vocale plutôt que le quota de minutes en direct. Identifiez la bonne catégorie lorsqu'un mode fonctionne et que l'autre échoue.

## Anticiper l'utilisation [#anticiper-lutilisation]

1. Choisissez des questions de visiteurs représentatives : courtes, normales et longues.
2. Testez séparément le texte, les réponses riches en connaissances, les messages vocaux et les appels en direct.
3. Notez les variations de crédits et de minutes pour votre jeu de tests d'acceptation.
4. Multipliez par le trafic quotidien attendu et la répartition par channel.
5. Prévoyez une marge pour les nouvelles tentatives, les explorations de sites, les défaillances de fournisseurs, les tests internes, les campagnes et les pics de trafic.
6. Revérifiez après tout changement de modèle, de fournisseur, de taille des sources, de longueur des réponses ou de comportement vocal.

Utilisez les analyses et les conversations pour identifier l'origine de la hausse. Un pic de trafic, un client API en boucle, une clé divulguée, une intégration copiée sur une origine non prévue, une nouvelle tentative d'un connector ou une tâche d'indexation répétée appellent chacun une correction différente.

## Prévenir une utilisation inattendue [#prévenir-une-utilisation-inattendue]

* Limitez les intégrations aux origines exactes prévues.
* Donnez aux clés API les portées les plus restreintes et séparez les clés par service et par environnement.
* Rendez les mutations idempotentes et respectez les en-têtes de nouvelle tentative `429`.
* Vérifiez les signatures des webhooks et dédupliquez les identifiants d'événements.
* Renouvelez immédiatement les identifiants API, de fournisseur ou de connector qui ont fuité.
* Gardez les agents publics encadrés par une persona claire et des consignes de réponse précises.
* Supprimez les automatisations obsolètes, les déploiements de prévisualisation, les connectors et les clés inutilisées.
* Alertez les responsables opérationnels avant que les soldes ou les minutes en direct n'approchent de zéro.

## Analyser un pic [#analyser-un-pic]

Notez l'espace de travail ou le site concerné, la plage horaire, le channel, le déploiement et les changements récents. Comparez l'utilisation avec les analyses, les horodatages des conversations, les identifiants de requêtes API, les journaux de livraison des webhooks et l'état du dernier événement ou de la dernière erreur du connector. N'envoyez pas de clés en clair ni de contenu de visiteurs au support, sauf si un processus sécurisé approuvé l'exige explicitement.

Commencez par contenir la source : désactivez un connector, révoquez une clé, supprimez une origine non prévue ou arrêtez la boucle de nouvelles tentatives d'un client. Ensuite, conservez les preuves sans risque, renouvelez les identifiants si nécessaire et réactivez les chemins un par un.

## Dépannage [#dépannage]

| Symptôme                                                    | À vérifier                                                                                                                   |
| ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Crédits épuisés alors qu'il reste des minutes en direct     | Les ressources sont distinctes ; ajoutez ou renouvelez des crédits pour le travail IA normal                                 |
| Les messages vocaux fonctionnent mais pas l'appel en direct | Droit d'utilisation du direct dans l'offre, minutes restantes, disponibilité du fournisseur temps réel et état de la session |
| Recharge achetée mais fonctionnalité toujours verrouillée   | Les packs n'ajoutent que des crédits ; vérifiez l'offre et le droit d'utilisation de l'agent                                 |
| L'API renvoie `429` alors qu'il reste des crédits           | Débit de requêtes par clé ; suivez les en-têtes de réinitialisation et de nouvelle tentative                                 |
| Le solde baisse de façon inattendue                         | Embeddings récents, connectors, clés API, indexation, voix et nouvelles tentatives du fournisseur ou du client               |

Consultez [Offres et tarifs](/fr/docs/account/pricing) pour le tableau actuel des droits d'utilisation.

---

# Domaines personnalisés

Source: /fr/docs/publish/custom-domains.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: &#x22;Présentation de l'intégration&#x22;, icon: &#x22;embed&#x22; },
{ href: &#x22;/fr/docs/embed/html&#x22;, label: &#x22;Extrait HTML&#x22;, icon: &#x22;code&#x22; }
]"
/>

Make Agent Fast ne vend, ne rattache, ne vérifie et ne configure **aucun** domaine client. Il n'existe pas de tableau de bord pour connecter `yourname.com` ou acheter un domaine. L'adresse `slug.makeagent.fast` de l'agent sert uniquement sa page de chat **Agent link**, et non un site web que vous pourriez configurer.

Placez l'agent sur le site web que vous possédez déjà avec `embed.js` et `data-agent="<slug>"`. Le slug est à la fois l'identifiant d'intégration et l'adresse de l'Agent link. Ce n'est pas un domaine que vous configurez.

Les événements résiduels de l'extension de domaine personnalisé Polar sont ignorés ou annulés et ne génèrent jamais de crédits.

Consultez [la présentation de l'intégration](/fr/docs/embed/overview) et [HTML et JavaScript](/fr/docs/embed/html).

---

# Agent link

Source: /fr/docs/publish/hosted-sites.md

{/* docs-visuals */}

<DocsChipRow
  items="[
{ href: &#x22;/fr/docs/build/appearance&#x22;, label: &#x22;Affichage&#x22;, icon: &#x22;spark&#x22; },
{ href: &#x22;/fr/docs/embed/overview&#x22;, label: &#x22;Intégration&#x22;, icon: &#x22;embed&#x22; }
]"
/>

Chaque agent dispose d'un **Agent link** : une page de chat publique à l'adresse `https://YOUR_SLUG.makeagent.fast`. Elle affiche le logo de votre entreprise, son nom, une ligne décrivant ce que fait l'agent, quelques informations issues de votre fact sheet, le chat déjà ouvert, ainsi que les marques officielles de vos canaux connectés. C'est un lien vers le chat, et non un site web ou une page d'accueil. **Les nouveaux agents n'ont pas de page marketing hébergée** : les sites marketing générés n'existent plus, et le principal moyen d'atteindre vos customers reste l'intégration sur votre site existant. Consultez [Présentation de l'intégration](/fr/docs/embed/overview).

Les pages de tenant déjà publiées (y compris les démos publiques `demo` et `demo-business`) continuent de s'afficher sur leurs sous-domaines, en tant que vestiges. Les domaines personnalisés ne sont pas proposés. Le slug est l'identifiant d'intégration (`data-agent`) et l'adresse de l'Agent link, et non un domaine que vous configurez.

<TutorialVideo episode="ep02" start="141" />

## Le slug reste l'identifiant d'intégration [#le-slug-reste-lidentifiant-dintégration]

Utilisez un nom court que vous reconnaissez. Un slug valide ne doit pas entrer en conflit avec un autre tenant ni avec une route réservée de la plateforme, comme `docs`, `dashboard` ou `api`. Considérez-le comme une information publique. Le modifier après le lancement peut casser les intégrations et l'Agent link.

## L'Agent link [#lagent-link]

La dernière étape de l'onboarding active l'Agent link afin que vous puissiez essayer l'agent sur votre téléphone sous **Tester sur votre téléphone**. Vous pouvez ensuite l'activer ou le désactiver avec **Agent link** dans l'onglet **Affichage** de la page de l'agent ; le lien et son QR code apparaissent tant qu'il est activé. Le désactiver retire le lien et enregistre votre choix. Un lien dont le contenu déclenche les contrôles anti-spam ne peut pas être mis en ligne.

La page n'est pas indexée par les moteurs de recherche. Partagez-la là où un script ne peut pas s'exécuter : une fiche Naver Place, un canal Kakao, une bio Instagram, une signature d'e-mail ou un QR code imprimé.

Les modifications de l'onglet **Affichage** (et du badge de marque) sont enregistrées automatiquement et mettent à jour l'intégration en ligne, le widget de l'Agent link et toute page hébergée héritée, sans nouvelle publication. Consultez [Apparence](/fr/docs/build/appearance).

## Connecter d'autres surfaces [#connecter-dautres-surfaces]

Les connectors de messagerie acheminent les conversations vers le même agent, mais conservent une identité de conversation propre à chaque channel. Activer le widget du site web n'installe pas automatiquement le snippet et ne configure pas les webhooks des fournisseurs ; suivez ces guides séparément.

Pour Notion, Linktree et les autres surfaces qui ne peuvent pas charger du JavaScript arbitraire, partagez l'Agent link ou faites un lien vers une page de votre propre site web qui contient l'intégration. Consultez [Notion et Linktree](/fr/docs/embed/notion-linktree).

## Dépublier [#dépublier]

Désactiver l'Agent link (ou envoyer `POST /sites/{site_id}/publish` avec `{ "published": false }`) retire la page de chat publique ainsi que toute page hébergée héritée. Masquer le widget du site web avec **L'afficher sur mon site** est un réglage distinct. Aucune de ces actions ne supprime le site, les sources, les agents, l'historique des conversations ni la configuration externe des fournisseurs. Les bots de messagerie connectés peuvent continuer à répondre ; désactivez ou supprimez chaque connector séparément.

## Dépannage [#dépannage]

| Symptôme                                                   | À vérifier                                                                                                                                   |
| ---------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| L'Agent link renvoie « indisponible » ou « introuvable »   | **Agent link** est activé dans l'onglet **Affichage**, le slug exact et l'accès actif au compte                                              |
| La modification du tableau de bord n'apparaît pas          | Le bon agent, l'indication **Enregistré** à côté de la modification, et un test en navigation privée de l'**intégration** ou de l'Agent link |
| Un connector répond alors que l'intégration est désactivée | Comportement normal ; désactivez le connector séparément si tout accès par ce channel doit cesser                                            |

---

# Connectez votre assistant IA

Source: /fr/docs/tutorials/ai-assistants.md

<TutorialEpisode
  episode="ep10"
  chapters="[
[0, &#x22;Introduction&#x22;],
[12, &#x22;Ce que votre application d'IA peut faire&#x22;],
[33, &#x22;Page de configuration de l'agent&#x22;],
[46, &#x22;Copier le prompt de configuration&#x22;],
[58, &#x22;Le coller dans Claude et valider&#x22;],
[87, &#x22;Poser des questions sur vos agents&#x22;],
[107, &#x22;Rapport hebdomadaire&#x22;],
[119, &#x22;Enregistrer une meilleure réponse&#x22;],
[130, &#x22;Codex&#x22;],
[147, &#x22;Cursor et ChatGPT&#x22;],
[165, &#x22;Révoquer l'accès&#x22;],
[177, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Utiliser Claude, Codex, Cursor et ChatGPT](/fr/docs/operate/ai-assistants)
* [Configuration de l'agent](/connect)

---

# Analytique, équipe et facturation

Source: /fr/docs/tutorials/analytics-team-billing.md

<TutorialEpisode
  episode="ep08"
  chapters="[
[0, &#x22;Introduction&#x22;],
[13, &#x22;Chiffres clés et comparaison&#x22;],
[31, &#x22;Tendances&#x22;],
[46, &#x22;Entonnoir et principales sources&#x22;],
[65, &#x22;Ce que demandent les visiteurs&#x22;],
[85, &#x22;Équipe et accès&#x22;],
[116, &#x22;Alertes&#x22;],
[132, &#x22;Votre forfait&#x22;],
[157, &#x22;Utilisation et crédits&#x22;],
[191, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Analytique](/fr/docs/operate/analytics)
* [Crédits et utilisation](/fr/docs/operate/usage)
* [Forfaits et tarifs](/fr/docs/account/pricing)
* [Sécurité](/fr/docs/account/security)

---

# Créez votre agent

Source: /fr/docs/tutorials/build-agent.md

<TutorialEpisode
  episode="ep01"
  chapters="[
[0, &#x22;Introduction&#x22;],
[14, &#x22;Créer un nouvel agent&#x22;],
[33, &#x22;Site web, nom, mission et langues&#x22;],
[61, &#x22;Création à partir de votre site web&#x22;],
[82, &#x22;Trois vérifications rapides&#x22;],
[110, &#x22;Choisir où il répond&#x22;],
[129, &#x22;La page Agent&#x22;],
[153, &#x22;Tester votre agent&#x22;],
[168, &#x22;Ajouter des connaissances et des questions-réponses&#x22;],
[218, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Créer un agent](/fr/docs/build/create-agent)
* [Sources de connaissances](/fr/docs/build/knowledge)
* [Démarrage rapide](/fr/docs/getting-started/quickstart)

---

# Votre boîte de réception

Source: /fr/docs/tutorials/inbox.md

<TutorialEpisode
  episode="ep06"
  chapters="[
[0, &#x22;Introduction&#x22;],
[14, &#x22;Conversations et filtres&#x22;],
[37, &#x22;Ouvrir une conversation&#x22;],
[50, &#x22;Répondre en tant que personne&#x22;],
[71, &#x22;Corriger une réponse&#x22;],
[95, &#x22;Notifications&#x22;],
[117, &#x22;Alertes sur votre téléphone&#x22;],
[134, &#x22;Approbations&#x22;],
[151, &#x22;Tickets&#x22;],
[171, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Conversations et leads](/fr/docs/operate/conversations)
* [Notifications](/fr/docs/operate/notifications)
* [Modifier les actions](/fr/docs/build/change-actions)

---

# Instagram : DM et commentaires

Source: /fr/docs/tutorials/instagram.md

<TutorialEpisode
  episode="ep05"
  chapters="[
[0, &#x22;Introduction&#x22;],
[15, &#x22;Ce dont vous avez besoin&#x22;],
[32, &#x22;Se connecter avec Meta&#x22;],
[46, &#x22;Choisir votre compte&#x22;],
[60, &#x22;Tester les DM et activer les réponses IA&#x22;],
[78, &#x22;Votre agent dans les DM Instagram&#x22;],
[95, &#x22;Réponses aux commentaires (bientôt disponible)&#x22;],
[134, &#x22;Les discussions Instagram dans Conversations&#x22;],
[154, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Instagram](/fr/docs/connectors/instagram)
* [Conversations et leads](/fr/docs/operate/conversations)

---

# Leads et pipeline de vente

Source: /fr/docs/tutorials/leads-sales.md

<TutorialEpisode
  episode="ep07"
  chapters="[
[0, &#x22;Introduction&#x22;],
[14, &#x22;Définir la mission commerciale&#x22;],
[33, &#x22;Pipeline de vente et leads&#x22;],
[62, &#x22;Tableau des opportunités&#x22;],
[90, &#x22;Politique de réponse et autorisation de contact&#x22;],
[108, &#x22;Fiche d'opportunité&#x22;],
[123, &#x22;Packs commerciaux et pilotes guidés&#x22;],
[146, &#x22;Diffusion KakaoTalk&#x22;],
[168, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Diffusions](/fr/docs/operate/broadcasts)
* [Conversations et leads](/fr/docs/operate/conversations)

---

# Messenger, Discord et KakaoTalk

Source: /fr/docs/tutorials/more-channels.md

<TutorialEpisode
  episode="ep09"
  chapters="[
[0, &#x22;Introduction&#x22;],
[15, &#x22;La même logique partout&#x22;],
[31, &#x22;Messenger : nous le connectons pour vous&#x22;],
[55, &#x22;Messenger : vos propres identifiants&#x22;],
[67, &#x22;Messenger : webhook&#x22;],
[89, &#x22;Discord Developer Portal&#x22;],
[107, &#x22;Connecter Discord&#x22;],
[123, &#x22;Utiliser /ask dans Discord&#x22;],
[145, &#x22;KakaoTalk : checklist Open Builder&#x22;],
[171, &#x22;KakaoTalk : identifiants et secret du bot&#x22;],
[196, &#x22;KakaoTalk en action&#x22;],
[218, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Messenger](/fr/docs/connectors/messenger)
* [Discord](/fr/docs/connectors/discord)
* [KakaoTalk](/fr/docs/connectors/kakao)

---

# Telegram : bots et groupes

Source: /fr/docs/tutorials/telegram.md

<TutorialEpisode
  episode="ep03"
  chapters="[
[0, &#x22;Introduction&#x22;],
[15, &#x22;Le plan&#x22;],
[27, &#x22;Ouvrir Channels&#x22;],
[45, &#x22;Créer un bot avec BotFather&#x22;],
[80, &#x22;Coller le token et se connecter&#x22;],
[103, &#x22;Test du channel et activation des réponses IA&#x22;],
[132, &#x22;Première conversation privée&#x22;],
[151, &#x22;Activer les réponses dans les groupes&#x22;],
[167, &#x22;Ajouter le bot à un groupe&#x22;],
[182, &#x22;Comportement dans les groupes&#x22;],
[202, &#x22;Règles de groupe et astuce de pro&#x22;],
[224, &#x22;Les conversations Telegram dans Conversations&#x22;],
[243, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Telegram](/fr/docs/connectors/telegram)
* [Conversations and leads](/fr/docs/operate/conversations)

---

# Ajoutez-le à votre site web

Source: /fr/docs/tutorials/website.md

<TutorialEpisode
  episode="ep02"
  chapters="[
[0, &#x22;Introduction&#x22;],
[13, &#x22;Installer sur votre site&#x22;],
[25, &#x22;Adresses de site web autorisées&#x22;],
[48, &#x22;Copier le code pour votre plateforme&#x22;],
[81, &#x22;Le widget sur votre site&#x22;],
[92, &#x22;Vérifier mon site&#x22;],
[108, &#x22;Styles prédéfinis et couleurs&#x22;],
[128, &#x22;Bulle flottante&#x22;],
[141, &#x22;Agent link et code QR&#x22;],
[163, &#x22;Masquer le widget&#x22;],
[175, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [Présentation de l'intégration](/fr/docs/embed/overview)
* [Affichage](/fr/docs/build/appearance)
* [Agent link](/fr/docs/publish/hosted-sites)

---

# WhatsApp

Source: /fr/docs/tutorials/whatsapp.md

<TutorialEpisode
  episode="ep04"
  chapters="[
[0, &#x22;Introduction&#x22;],
[15, &#x22;Ce dont vous avez besoin&#x22;],
[31, &#x22;Configuration du numéro et Connect with Meta&#x22;],
[49, &#x22;Inscription Meta&#x22;],
[65, &#x22;Choisir votre numéro&#x22;],
[78, &#x22;Test du channel et activation des réponses de l'IA&#x22;],
[106, &#x22;Votre agent sur WhatsApp&#x22;],
[124, &#x22;La fenêtre de 24 heures&#x22;],
[140, &#x22;Les chats WhatsApp dans Conversations&#x22;],
[153, &#x22;Nous le connectons pour vous&#x22;],
[165, &#x22;Récapitulatif&#x22;]
]"
/>

## Guides associés [#guides-associés]

* [WhatsApp](/fr/docs/connectors/whatsapp)
* [Conversations et leads](/fr/docs/operate/conversations)