Intégration Copilot MakeAutomatiser Copilot avec Make.

Ramène tes clients Copilot dans le scénario, un bundle par client, pour traiter toute la base ou une partie filtrée.

Crée un client dans Copilot à partir d'infos récupérées ailleurs : une inscription ou une affaire gagnée devient un compte client sans ressaisie.

Va chercher un client précis dans Copilot avec tout ce que l'API renvoie, bien pratique quand un module précédent ne t'a donné qu'un identifiant.

Supprime un client de Copilot au fil d'un scénario, pour que la sortie d'un client dans un autre outil nettoie aussi Copilot.

Modifie un client existant dans Copilot avec les données des modules précédents, pour que Copilot reflète ta source de référence.

Renvoie les options définies pour tes champs personnalisés Copilot, et le scénario travaille avec les libellés choisis par ton équipe plutôt qu'avec des valeurs brutes.

Fait entrer toutes les sociétés Copilot dans le scénario, une par bundle, pour un bilan de tes comptes ou un rapprochement avec un autre système.

Ouvre une nouvelle société dans Copilot pour regrouper dès le départ les clients d'une même structure, à partir des données d'une autre app.

Lit la fiche complète d'une société Copilot à partir de son identifiant, et les modules suivants disposent de ce qu'un déclencheur seul ne transmet pas toujours.

Met à jour une société dans Copilot avec des données mappées, et les infos de la structure restent identiques d'un outil à l'autre sans copier-coller.

Efface une société de Copilot dans un scénario, utile quand la structure est fermée dans l'outil qui te sert de référence.

Renvoie les fichiers stockés dans Copilot en bundles séparés, la bonne voie pour passer en revue ou exporter beaucoup de documents d'un coup.

Liste les canaux de fichiers de ton espace Copilot, un bundle par canal, pour que le scénario sache où déposer un document.

Crée un canal de fichiers dans Copilot, et un client ou une société obtient sa place dédiée aux documents directement depuis ton scénario.

Charge un canal de fichiers par son identifiant, et les modules suivants savent à qui il appartient avant d'agir dessus.

Récupère la fiche d'un fichier Copilot, et le scénario sait de quoi il s'agit avant de décider de le télécharger, le déplacer ou l'annoncer.

Rapatrie le contenu réel d'un fichier Copilot dans le scénario, pour qu'un autre module le dépose sur un drive, le joigne à un e-mail ou l'archive.

Te donne une adresse de téléchargement pour un fichier Copilot au lieu du fichier lui-même, plus léger quand l'outil suivant n'a besoin que d'un lien.

Dépose un nouveau fichier dans Copilot à partir d'un contenu produit ou récupéré plus tôt, et les documents rejoignent l'espace client sans envoi manuel.

Crée un dossier dans l'espace fichiers de Copilot et structure l'espace client dès que le scénario l'ouvre.

Ajoute un lien dans un espace fichiers Copilot et oriente le client vers une ressource hébergée dans un autre outil, sans copier le fichier.

Retire un fichier de Copilot pendant un scénario, pour garder les espaces clients propres quand un document est remplacé ou périmé.

Renvoie les formulaires de ton espace Copilot, un bundle par formulaire, et le scénario peut trouver le bon questionnaire à envoyer.

Récupère les réponses envoyées à tes formulaires Copilot, chacune dans son bundle, pour les analyser ou les stocker ailleurs.

Charge un formulaire Copilot avec ses détails, de quoi étiqueter les réponses ou reprendre son nom dans un message.

Demande à un client de remplir un formulaire Copilot : les questionnaires partent dans le flux, plus de mémoire.

Renvoie les modèles de contrat stockés dans Copilot, un par bundle, pour que le scénario choisisse quel accord envoyer.

Récupère un modèle de contrat Copilot, et le scénario peut lire ses détails avant qu'un contrat ne parte.

Fait entrer les contrats Copilot dans ton scénario, un bundle par contrat, pour un reporting ou une synchro avec tes outils commerciaux.

Va chercher un contrat précis avec ses détails, et un identifiant venu d'un déclencheur devient une info exploitable dans tes autres apps.

Envoie un contrat Copilot à un client depuis ton scénario : l'accord part dès que l'affaire est prête.

Renvoie les messages des conversations Copilot en bundles individuels, utile pour archiver ou relire des échanges avec un client.

Liste les canaux de discussion de Copilot, et le scénario retrouve la conversation d'un client donné avant d'y écrire.

Ouvre un canal de discussion par son identifiant, et le scénario sait qui y participe avant de publier ou de noter quoi que ce soit.

Ouvre un nouveau canal de discussion dans Copilot, et le client a un endroit pour échanger avec ton équipe dès que le scénario le décide.

Publie un message dans un canal Copilot depuis ton scénario, et tes clients sont informés d'une facture, d'un fichier ou d'une étape sans que personne ne tape une ligne.

Renvoie les membres de ton équipe dans Copilot, un bundle par personne, pour attribuer du travail ou vérifier qui a un accès.

Lit la fiche d'un collègue dans Copilot, et le scénario dispose d'un nom ou d'un contact à reprendre dans une notification.

Lit les infos de ton espace Copilot lui-même, celui auquel appartient la clé API de ta connexion.

Liste les apps installées dans ton espace Copilot, un bundle par app, pour que le scénario sache quelles extensions sont actives.

Récupère les connexions d'apps enregistrées dans ton espace Copilot, une par bundle, pour les consulter depuis Make sans fouiller dans les réglages.

Ajoute une connexion d'app dans Copilot depuis le scénario : l'accès d'un client se met en place tout seul dès qu'un événement survient dans un autre outil.

Rapatrie les factures de ton espace Copilot dans Make, chacune dans son bundle, prêtes à partir vers un tableur, un logiciel comptable ou un reporting.

Sort les abonnements stockés dans Copilot, un bundle par abonnement, pour rendre la facturation récurrente lisible hors de Copilot.

Renvoie les paiements enregistrés dans Copilot pour que le scénario les rapproche de ton relevé bancaire ou de ta compta.

Affiche les modèles de facture configurés dans Copilot, ce qui aide à choisir le bon avant que le scénario émette une facture.

Liste les modèles d'abonnement disponibles dans Copilot, pour que le scénario sache quelles offres récurrentes il peut rattacher à un client.

Émet une facture dans Copilot à partir des données qui arrivent dans le scénario : fini la recopie des montants à la main.

Lance l'abonnement d'un client dans Copilot depuis Make, pour qu'un accord conclu ailleurs devienne une facturation récurrente sans geste manuel.

Va chercher une facture Copilot par son ID et transmet son détail aux modules suivants, pour une relance par e-mail ou une ligne dans un journal.

Lit un abonnement Copilot précis et fait suivre ses informations, pour que le scénario décide de la suite selon son état actuel.

Met fin à l'abonnement d'un client dans Copilot depuis Make : un départ acté ailleurs arrête aussi la facturation.

Liste les produits définis dans Copilot, un bundle par produit, pratique pour garder un catalogue aligné avec un autre outil.

Ouvre un produit Copilot par son ID et met son détail à disposition du reste du scénario, pour un devis ou une notification.

Renvoie les prix fixés dans Copilot, chacun dans son bundle, pour les comparer, les exporter ou les confronter à une autre grille.

Lit un prix Copilot et le passe au module suivant, utile quand une ligne de devis ou de facture ailleurs doit lui correspondre.

Écrit une note dans Copilot à partir de n'importe quel événement du scénario, pour que le contexte d'un appel ou d'un ticket atterrisse là où l'équipe regarde.

Récupère une note Copilot par son ID avec son contenu, pour la recopier, la résumer ou l'envoyer à quelqu'un.

Ramène les notes enregistrées dans Copilot, un bundle chacune, pour les archiver ou les déplacer vers un autre outil de documentation.

Modifie une note existante dans Copilot : une note créée plus tôt se complète au fil des nouvelles informations.

Supprime une note de Copilot via le scénario, pratique pour nettoyer des notes qui ne servaient que de pense-bête.

Renvoie les tâches de ton espace Copilot, une par bundle, pour les refléter dans un outil de gestion de projet ou un tableur partagé.

Ajoute une tâche dans Copilot quand quelque chose se passe ailleurs : plus besoin de penser à ouvrir Copilot pour la saisir.

Sort une tâche Copilot par son ID et confie son détail aux modules suivants, pour une relance ou une mise à jour de statut dans un autre outil.

Efface une tâche dans Copilot depuis le scénario, ce qui garde la liste propre quand le travail a été annulé ailleurs.

Corrige une tâche Copilot existante pour qu'elle suive les changements de tes autres outils, sans en créer une seconde.

Affiche les modèles de tâche enregistrés dans Copilot, pour que le scénario choisisse le bon avant de créer du travail pour un client.

Lit un modèle de tâche Copilot par son ID et expose son contenu, que le scénario peut réutiliser en créant de nouvelles tâches.

Atteint n'importe quel endpoint de l'API Copilot avec la même connexion que les autres modules : de quoi couvrir ce que les modules prêts à l'emploi ne proposent pas.