Publipostage Teams personnalisé : Graph API, Power Automate, Python & PowerShell (guide complet)

Vous devez prévenir 50 ou 5 000 collaborateurs par message privé sur Microsoft Teams sans copier‑coller ? Ce guide compare les approches (Power Automate, Microsoft Graph, scripts) et livre des pas‑à‑pas + du code pour envoyer des messages 1‑à‑1 personnalisés depuis un fichier Excel.

Sommaire

Vue d’ensemble de la question

Objectif : expédier, depuis Teams, des messages privés et personnalisés à un ensemble de destinataires listés dans un fichier Excel (colonnes : Nom, E‑mail, Texte du message) sans passer par des copier‑coller manuels. Les équipes IT souhaitent généralement : (1) un pilotage fiable (log des envois, gestion des erreurs, reprise), (2) une conformité RGPD et sécurité, (3) une expérience “vrai message Teams” côté utilisateur, et (4) une solution proportionnée au volume et aux compétences disponibles.

Solutions discutées

Approche	Principe	Avantages	Limitations / Pré‑requis
Microsoft Graph API	Créer un script (PowerShell, Python, C#, etc.) qui lit le fichier Excel, boucle sur chaque ligne et envoie un message via l’endpoint `/chats/{chat-id}/messages`.	• 100 % automatisable • Messages réellement envoyés dans le chat 1‑to‑1 de Teams • Possibilité de journaliser les réponses	• Nécessite un enregistrement d’application Azure AD, des scopes typiques Chat.ReadWrite et ChatMessage.Send (ou équivalents selon le mode) • Compétences de développement obligatoires • Soumis aux quotas et au throttling Graph
Power Automate	Créer un flux : déclencheur « À la demande » → action « Lire les lignes » (Excel) → action « Envoyer un message dans un chat ou canal ».	• Interface low‑code • Peut être lancé par un utilisateur non‑développeur	• L’historique des conversations apparaît comme généré par le connecteur, pas comme un vrai chat individuel de l’utilisateur émetteur • Gestion des réponses plus complexe
Copilot Studio / Bot Framework	Concevoir un bot qui récupère l’Excel et envoie les messages.	• Puissant pour scénarios conversationnels complexes	• Surdimensionné et coûteux pour un simple publipostage
Publipostage Outlook (« Mail Merge »)	Utiliser Excel comme source d’un publipostage e‑mail.	• Solution prête à l’emploi • Personnalisation riche via champs de fusion	• Les messages partent par e‑mail, pas par Teams
Scripts Office Scripts / VBA	Depuis Excel Web ou Desktop, appeler l’API Graph directement.	• Automatisable depuis le classeur • Pas de service externe	• Connaissances JavaScript ou VBA requises
Azure Logic Apps	Variante cloud de Power Automate, adaptée aux gros volumes et à l’orchestration B2B.	• Mise à l’échelle simplifiée	• Coût à la consommation

Choisir la bonne approche

La bonne méthode dépend de votre volume, de la sensibilité des messages et des compétences disponibles.

Jusqu’à ~200 destinataires, aucun code : un flux Power Automate manuel (Instant cloud flow) est souvent suffisant. C’est rapide, visuel, repris par un collègue facilement.
Au‑delà / exigences d’audit, relances, orchestrations : script via Microsoft Graph (Python ou PowerShell). Vous contrôlez les logs, la temporisation, la reprise en cas d’erreur, l’intégration SSO, etc.
Gros volumes récurrents : Azure Logic Apps (équivalent “pro” de Power Automate) pour une exécution robuste et élastique.

Préparer la source Excel

Créez un tableau nommé (Insertion > Tableau) avec les colonnes : Nom, Email, Message. Exemple :

Nom	Email	Message
Camille Dupont	camille.dupont@contoso.com	Bonjour Camille, votre accès au portail sera mis à jour demain.
Ousmane Diallo	ousmane.diallo@contoso.com	Bonjour Ousmane, merci de finaliser l’inscription avant vendredi.

Astuce : utilisez des variables de fusion simples dans la colonne Message (ex. {{Nom}}). Les scripts ci‑dessous remplacent automatiquement ces jetons.

Mise en œuvre avec Power Automate (no‑code)

Étapes de base

Déclencheur : « À la demande » pour lancer le flux manuellement (ou un déclencheur planifié si besoin).
Lire Excel : action « Lister les lignes présentes dans un tableau » (sélectionnez le fichier sur OneDrive/SharePoint et le tableau nommé).
Pour chaque ligne : ajoutez un bloc « Appliquer à chaque » basé sur la liste lue.
Composer le message : action « Composer » (optionnelle) pour injecter {{Nom}} → Nom (contenu dynamique).
Envoyer dans Teams : action « Envoyer un message dans un chat ou canal ». Cible : Utilisateur → fournissez le champ Email de la ligne. Message : le texte personnalisé.
Temporisation : ajoutez « Attendre » 1 s à l’intérieur de la boucle pour limiter le risque de throttling.
Traçabilité : écrivez dans une liste SharePoint (ou Dataverse) « Email, Date, Statut, IdMessage » après chaque envoi.

Bon à savoir côté Power Automate

Le message peut apparaître comme envoyé par le connecteur (Flow bot). Si vous avez besoin que le message parte vraiment du chat 1‑à‑1 d’un utilisateur donné, préférez l’API Graph avec délegated permissions (exécution au nom de l’utilisateur).
Le connecteur Teams accepte le HTML simple ; testez votre mise en forme (gras, liens internes, sauts de ligne) et évitez les médias lourds.
Pour un Excel volumineux, activez la pagination et filtrez par lots (ex. 500 lignes).

Mise en œuvre avec Microsoft Graph (Python)

Ce modèle envoie des messages personnalisés à partir d’un Excel et consigne chaque envoi. Il illustre : authentification, résolution d’utilisateurs par e‑mail, création/obtention d’un chat 1‑à‑1, envoi du message, backoff sur throttling (HTTP 429), et journalisation.

Prérequis

Application Azure AD enregistrée (client ID, tenant ID, secret ou certificat).
Autorisations adéquates (à ajuster selon votre mode) : typiquement Chat.ReadWrite et ChatMessage.Send en délégué, ou Chat.ReadWrite.All en application. L’approbation d’un administrateur peut être nécessaire.
Paquets : msal, pandas, openpyxl, requests.

Structure générale

# pip install msal pandas openpyxl requests
import os, time, json, csv, requests
import pandas as pd
from typing import Optional

GRAPH = "[https://graph.microsoft.com/v1.0](https://graph.microsoft.com/v1.0)"

TENANT_ID   = os.getenv("TENANT_ID")
CLIENT_ID   = os.getenv("CLIENT_ID")
CLIENT_SECRET = os.getenv("CLIENT_SECRET")
SCOPE = ["[https://graph.microsoft.com/.default](https://graph.microsoft.com/.default)"]  # client credentials
SENDER_UPN = os.getenv("SENDER_UPN")  # compte service ou compte réel, selon le mode

from msal import ConfidentialClientApplication

def token():
app = ConfidentialClientApplication(
client_id=CLIENT_ID,
authority=f"[https://login.microsoftonline.com/{TENANT_ID}](https://login.microsoftonline.com/{TENANT_ID})",
client_credential=CLIENT_SECRET
)
result = app.acquire_token_silent(SCOPE, account=None)
if not result:
result = app.acquire_token_for_client(scopes=SCOPE)
if "access_token" not in result:
raise RuntimeError(f"Auth error: {result}")
return result["access_token"]

def h(tok):  # headers
return {"Authorization": f"Bearer {tok}", "Content-Type": "application/json"}

def find_user_id_by_email(tok, email: str) -> Optional[str]:
# Tentative directe par UPN, puis fallback sur filtre mail
r = requests.get(f"{GRAPH}/users/{email}", headers=h(tok), params={"$select":"id,displayName,mail,userPrincipalName"})
if r.status_code == 200:
return r.json()["id"]
q = f"mail eq '{email}' or userPrincipalName eq '{email}'"
r = requests.get(f"{GRAPH}/users", headers=h(tok), params={"$select":"id,mail,userPrincipalName","$filter":q})
if r.status_code == 200:
data = r.json().get("value", [])
return data[0]["id"] if data else None
return None

def get_user_id(tok, upn: str) -> str:
r = requests.get(f"{GRAPH}/users/{upn}", headers=h(tok), params={"$select":"id"})
r.raise_for_status()
return r.json()["id"]

def ensure_one_on_one_chat(tok, user1_id: str, user2_id: str) -> str:
"""
Essaye d'abord de créer un chat 1‑à‑1. Si l'API répond qu'il existe déjà,
bascule sur une recherche paginée (simplifiée ici).
"""
body = {
"chatType": "oneOnOne",
"members": [
{
"@odata.type": "#microsoft.graph.aadUserConversationMember",
"roles": ["owner"],
"[user@odata.bind](mailto:user@odata.bind)": f"{GRAPH}/users('{user1_id}')"
},
{
"@odata.type": "#microsoft.graph.aadUserConversationMember",
"roles": ["owner"],
"[user@odata.bind](mailto:user@odata.bind)": f"{GRAPH}/users('{user2_id}')"
}
]
}
r = requests.post(f"{GRAPH}/chats", headers=h(tok), data=json.dumps(body))
if r.status_code in (201, 200):
return r.json()["id"]
# Recherche basique: lister les chats de user1 et filtrer ceux à 2 membres
# (nécessite les permissions adéquates). Pour brevité, on interroge /users/{id}/chats
# et on s'arrête au premier chat 1‑à‑1 contenant user2.
if r.status_code in (409, 400, 403):
url = f"{GRAPH}/users/{user1_id}/chats?$filter=chatType eq 'oneOnOne'&$select=id"
while url:
r2 = requests.get(url, headers=h(tok))
r2.raise_for_status()
data = r2.json()
for c in data.get("value", []):
cid = c["id"]
m = requests.get(f"{GRAPH}/chats/{cid}/members?$select=userId", headers=h(tok))
if m.status_code == 200:
mids = [itm.get("userId") for itm in m.json().get("value", [])]
if user2_id in mids:
return cid
url = data.get("@odata.nextLink")
r.raise_for_status()
raise RuntimeError("Impossible de résoudre le chat 1‑à‑1.")

def send_message(tok, chat_id: str, html: str) -> dict:
payload = {"body": {"contentType": "html", "content": html}}
attempt, delay = 0, 1
while True:
r = requests.post(f"{GRAPH}/chats/{chat_id}/messages", headers=h(tok), data=json.dumps(payload))
if r.status_code in (200, 201, 202):
return r.json()
if r.status_code == 429:
retry = int(r.headers.get("Retry-After", delay))
time.sleep(max(retry, delay))
attempt += 1
delay = min(delay * 2, 60)
continue
if r.status_code in (503, 504):
time.sleep(delay)
attempt += 1
delay = min(delay * 2, 60)
continue
r.raise_for_status()

def personalize(template: str, row: dict) -> str:
msg = template.replace("{{Nom}}", str(row.get("Nom") or row.get("nom") or ""))
return msg

def run(excel_path: str, sheet: Optional[str] = None, log_csv: str = "journal_envois.csv"):
tok = token()
sender_id = get_user_id(tok, SENDER_UPN)
df = pd.read_excel(excel_path, sheet_name=sheet)
df = df.fillna("")
with open(log_csv, "a", newline="", encoding="utf-8") as f:
w = csv.writer(f)
if f.tell() == 0:
w.writerow(["email","chatId","messageId","status","timestamp"])
for _, row in df.iterrows():
email = str(row.get("Email") or row.get("E-mail") or "").strip()
if not email:
continue
user_id = find_user_id_by_email(tok, email)
if not user_id:
w.writerow([email,"","", "USER_NOT_FOUND", time.strftime("%Y-%m-%d %H:%M:%S")])
continue
chat_id = ensure_one_on_one_chat(tok, sender_id, user_id)
html = personalize(str(row.get("Message")), row)
res = send_message(tok, chat_id, html)
w.writerow([email, chat_id, res.get("id",""), "SENT", time.strftime("%Y-%m-%d %H:%M:%S")])
time.sleep(1)  # temporisation anti‑throttling
print("Terminé.")

Exécution :

set TENANT_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
set CLIENT_ID=yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy
set CLIENT_SECRET=***************
set SENDER_UPN=compte.service@contoso.com
python bulk_teams.py

Notes : selon la configuration de votre tenant et les autorisations consenties, la création d’un chat 1‑à‑1 par une application peut être restreinte. Dans ce cas, exécutez le script en delegated (au nom d’un utilisateur) ou préparez les chats à l’avance (premier message manuel) puis utilisez uniquement /chats/{chat-id}/messages.

Alternative : Microsoft Graph en PowerShell (SDK officiel)

Pour les administrateurs habitués à PowerShell, le module Graph accélère la mise en place et la lecture d’Excel.

# Préparer l'environnement
# Install-Module Microsoft.Graph -Scope CurrentUser
# Import-Module Microsoft.Graph

Connect-MgGraph -Scopes "Chat.ReadWrite","ChatMessage.Send","User.Read.All"
Select-MgProfile -Name "v1.0"

# Chemin du fichier Excel (format .xlsx, tableau nommé)

$excelPath = "C:\Temp\contacts.xlsx"
$sheet = "Feuil1"

# Lis les lignes via COM Excel (pour simplifier la démo). En production, préférez

# un import CSV ou l'API Graph pour lire un fichier sur OneDrive/SharePoint.

$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$wb = $excel.Workbooks.Open($excelPath)
$ws = $wb.Sheets.Item($sheet)
$range = $ws.UsedRange
$rows = @()
$headers = @()
for ($c=1; $c -le $range.Columns.Count; $c++) { $headers += $range.Cells.Item(1,$c).Text }
for ($r=2; $r -le $range.Rows.Count; $r++) {
$obj = [ordered]@{}
for ($c=1; $c -le $headers.Count; $c++) { $obj[$headers[$c-1]] = $range.Cells.Item($r,$c).Text }
$rows += (New-Object PSObject -Property $obj)
}
$wb.Close($false)
$excel.Quit()

function Get-UserIdByEmail {
param([string]$Email)
try {
$u = Get-MgUser -UserId $Email -Property Id -ErrorAction Stop
return $u.Id
} catch {
$u = Get-MgUser -Filter "mail eq '$Email' or userPrincipalName eq '$Email'" -All
return $u[0].Id
}
}

function Ensure-OneOnOneChat {
param([string]$SenderId, [string]$RecipientId)
$body = @{
chatType = "oneOnOne"
members = @(
@{
"@odata.type" = "#microsoft.graph.aadUserConversationMember"
roles = @("owner")
"[user@odata.bind](mailto:user@odata.bind)" = "[https://graph.microsoft.com/v1.0/users('$SenderId](https://graph.microsoft.com/v1.0/users%28'$SenderId)')"
},
@{
"@odata.type" = "#microsoft.graph.aadUserConversationMember"
roles = @("owner")
"[user@odata.bind](mailto:user@odata.bind)" = "[https://graph.microsoft.com/v1.0/users('$RecipientId](https://graph.microsoft.com/v1.0/users%28'$RecipientId)')"
}
)
}
try {
$chat = Invoke-MgGraphRequest -Method POST -Uri "[https://graph.microsoft.com/v1.0/chats](https://graph.microsoft.com/v1.0/chats)" -Body ($body | ConvertTo-Json -Depth 6)
return $chat.id
} catch {
# Recherche fallback si le chat existe déjà
$chats = Invoke-MgGraphRequest -Method GET -Uri "[https://graph.microsoft.com/v1.0/users/$SenderId/chats?`$filter=chatType](https://graph.microsoft.com/v1.0/users/$SenderId/chats?`$filter=chatType) eq 'oneOnOne'&`$select=id" 
    foreach ($c in $chats.value) {
      $m = Invoke-MgGraphRequest -Method GET -Uri "https://graph.microsoft.com/v1.0/chats/$($c.id)/members?`$select=userId"
if ($m.value.userId -contains $RecipientId) { return $c.id }
}
throw
}
}

$senderUpn = Read-Host "UPN de l'émetteur (ex. [compte.service@contoso.com](mailto:compte.service@contoso.com))"
$sender = Get-MgUser -UserId $senderUpn -Property Id
$log = @()

foreach ($row in $rows) {
$email = $row.Email
if ([string]::IsNullOrEmpty($email)) { continue }
$recipientId = Get-UserIdByEmail -Email $email
if (-not $recipientId) {
$log += [pscustomobject]@{Email=$email; Status="USER_NOT_FOUND"; MessageId=""; ChatId=""}
continue
}
$chatId = Ensure-OneOnOneChat -SenderId $sender.Id -RecipientId $recipientId
$html = ($row.Message -replace "{{Nom}}", $row.Nom)
$payload = @{ body = @{ contentType="html"; content=$html } } | ConvertTo-Json -Depth 5

$sent = $false; $delay = 1
for ($i=0; $i -lt 6 -and -not $sent; $i++) {
$resp = Invoke-WebRequest -Method POST -Uri "[https://graph.microsoft.com/v1.0/chats/$chatId/messages](https://graph.microsoft.com/v1.0/chats/$chatId/messages)" `      -Headers @{Authorization = "Bearer $((Get-MgContext).AccessToken)"}`
-Body $payload -ContentType "application/json" -UseBasicParsing -ErrorAction SilentlyContinue
if ($resp.StatusCode -in 200,201,202) { $sent = $true; break }
if ($resp.StatusCode -eq 429 -or $resp.StatusCode -eq 503) { Start-Sleep -Seconds $delay; $delay = [Math]::Min($delay*2, 60) }
else { break }
}
$msgId = ""
if ($sent) { $msg = $resp.Content | ConvertFrom-Json; $msgId = $msg.id }
$log += [pscustomobject]@{Email=$email; Status=($sent?"SENT":"FAILED"); MessageId=$msgId; ChatId=$chatId}
Start-Sleep -Milliseconds 1000
}

$log | Export-Csv -Path ".\journal_envois_ps.csv" -NoTypeInformation -Encoding UTF8
Write-Host "Terminé."

Office Scripts (Excel sur le Web) : appel Graph côté classeur

Pour un scénario « tout‑en‑un » dans Excel Web, vous pouvez déclencher un Office Script. Exemple minimal : lecture des lignes d’un tableau et envoi via un endpoint HTTP (proxy/Power Automate/Logic Apps) qui relaie vers Graph. C’est souvent plus simple car le script n’a pas accès directement au jeton Graph sans passerelle sécurisée.

// Office Script (TypeScript) - déclenche un flux HTTP intermédaire
async function main(workbook: ExcelScript.Workbook) {
  const sheet = workbook.getActiveWorksheet();
  const table = workbook.getTable("Contacts");
  const rows = table.getRangeBetweenHeaderAndTotal().getValues();
  const headers = table.getHeaderRowRange().getValues()[0];

const data = rows.map(r => Object.fromEntries(r.map((v,i)=>[headers[i], v])));

const payload = JSON.stringify({ rows: data });
// Envoyer au point d'entrée HTTP d'un flux Power Automate/Logic App
await fetch("[https://votre-endpoint-intermediaire/ingest](https://votre-endpoint-intermediaire/ingest)", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: payload
});
}

Remarque : ce motif « proxy » garantit que les secrets et autorisations Graph restent côté service, pas dans le classeur.

Bonnes pratiques complémentaires

Sécurisation : limitez les permissions au strict minimum ; stockez secrets/certificats dans un coffre (ex. Key Vault). Privilégiez des comptes de service restreints et des rôles ad hoc.
Quota & Throttling : temporisez (≥ 1 s) entre envois ; respectez l’en‑tête Retry-After sur HTTP 429 et implémentez un exponential backoff.
Suivi : journalisez pour chaque e‑mail : horodatage, statut, chatId, messageId, erreur éventuelle. Conservez les tentatives/ré‑essais.
Gestion des réponses : si vous devez traiter les retours, abonnez‑vous aux notifications (webhooks) sur les chats ou mettez en place une lecture périodique des messages entrants.
Licence / conformité : l’envoi massif peut s’apparenter à une communication marketing ; validez la politique interne, la base légale (intérêt légitime, consentement) et la minimisation de données. Offrez un canal clair pour se désinscrire des prochains envois.

Personnalisation du message et enrichissements

Jetons : utilisez {{Nom}}, {{Équipe}}, {{Date}}… remplacez‑les côté script/flow.
HTML simple : titres <strong>, listes <ul><li>, liens internes à l’intranet, paragraphes. Évitez les images lourdes.
Adaptive Cards : pour des interactions (boutons, formulaires), envisagez des cartes envoyables via Graph. Vérifiez l’alignement avec vos politiques Teams.
Mentions : pour @mentionner, renseignez la collection mentions dans le corps du message et référencez‑la dans le HTML. Testez à petite échelle.

Scénarios limites & décisions

Cas	Recommandation
Destinataires externes (invités)	Vérifiez l’existence d’un compte invité dans le tenant. À défaut, basculez vers l’e‑mail.
Message transactionnel critique	Préférez Graph + journalisation + retry. Envisagez une double notification (Teams + e‑mail).
Campagne répétitive mensuelle	Industrialisez (Logic Apps), planifiez, versionnez vos modèles de message.
Réponses attendues	Activez un traitement automatique (webhook + Azure Function) ou routez vers un canal avec suivi.

Dépannage (erreurs fréquentes)

Symptôme	Cause probable	Piste de résolution
401 / 403 à l’appel Graph	Jeton invalide, consentement admin manquant, permission insuffisante	Régénérez le jeton, revérifiez les scopes, faites consentir un administrateur et attendez la propagation.
404 sur `/chats/{id}`	Chat inexistant ou non accessible par l’application	Créez le 1‑à‑1 au préalable, exécutez en délégué, ou vérifiez que l’app peut lister les chats.
429 (throttling)	Trop d’appels rapprochés	Respectez `Retry-After`, ajoutez une temporisation fixe, répartissez les lots (ex. 200 destinataires/lot).
Utilisateur introuvable	Divergence entre UPN et e‑mail, compte désactivé, invité non provisionné	Résolvez par filtre sur `mail` OR `userPrincipalName`, sinon mettez en file d’attente pour traitement manuel.
Message non formaté	HTML invalide ou trop complexe	Simplifiez en HTML basique (p, strong, ul/li, br), testez un échantillon avant campagne.

Checklist de mise en production

✅ Fichier Excel propre : en‑têtes normalisés, adresses e‑mail validées, champs obligatoires présents.
✅ Permissions Graph validées et consenties, rotation de secrets planifiée.
✅ Journalisation & observabilité : CSV/SharePoint/SQL + remontée d’erreurs.
✅ Backoff/Retry en place et temporisation minimale.
✅ Test pilote (10‑20 destinataires) puis montée progressive.
✅ Conformité : base légale, bandeau d’information, canal de désinscription.

FAQ

Peut‑on envoyer au nom du CEO ? Oui si vous exécutez en délégué (session authentifiée du CEO) ou via un compte de service autorisé selon votre gouvernance. Évitez les usurpations ; laissez une traçabilité claire.

Et si un destinataire n’a jamais discuté avec l’émetteur dans Teams ? Le script peut créer le chat 1‑à‑1 (si autorisé) ou vous pouvez amorcer le premier message manuellement.

Peut‑on joindre un PDF/image ? Oui via Graph avec une ressource de type pièce jointe. Testez l’impact sur le throttling et la taille.

Pourquoi pas un canal ? Un canal convient aux annonces larges. Ici, la contrainte est la personnalisation et le 1‑à‑1.

Recommandation rapide

Moins de 200 destinataires, aucune compétence code : Power Automate suffit.
Volume élevé ou besoin de contrôle total : script utilisant Microsoft Graph API (Python ou PowerShell) avec un compte de service dédié.

Ces options couvrent l’ensemble des scénarios, du no‑code au code complet, tout en maîtrisant les implications techniques et réglementaires.

Annexe : modèle d’Excel (copier‑coller)

Nom,Email,Message
Camille Dupont,camille.dupont@contoso.com,"Bonjour {{Nom}}, votre accès au portail sera mis à jour demain."
Ousmane Diallo,ousmane.diallo@contoso.com,"Bonjour {{Nom}}, merci de finaliser l'inscription avant vendredi."

Annexe : squelette JSON d’un message Graph

{
  "body": {
    "contentType": "html",
    "content": "&lt;p&gt;Bonjour Camille, votre accès sera mis à jour.&lt;/p&gt;"
  }
}

En résumé : commencez simple (Power Automate), puis passez au script Graph pour l’échelle, les relances, la traçabilité et l’intégration à vos systèmes. Gardez un œil sur la sécurité (permissions minimales, coffre‑fort de secrets), la conformité (RGPD) et la robustesse (backoff, logs, reprise).

Publipostage Teams personnalisé : Graph API, Power Automate, Python & PowerShell (guide complet)