---
title: Récupérer les transcriptions de sessions
url: https://platform.claude.com/docs/fr/manage-claude/compliance-sessions
description: Listez les sessions que vos utilisateurs exécutent dans les applications et agents Claude, comme Claude Cowork et Claude Code, et récupérez leurs transcriptions via la Compliance API.
---

<Note>
  Les points de terminaison de cette page sont disponibles uniquement pour les organisations Claude Enterprise. Les points de terminaison de sessions locales et distantes sont stables pour les sessions Cowork, Claude Code et Claude for Microsoft 365. La couverture des sessions dans Claude Science, dans les compléments Claude pour Google Docs, Google Sheets et Google Slides, dans Claude in Chrome et dans Claude Tag est en bêta. Les points de terminaison fonctionnent avec la même Compliance Access Key et la même portée `read:compliance_user_data` que les [points de terminaison des chats, fichiers et projets](https://platform.claude.com/docs/fr/manage-claude/compliance-content-data) ; aucune nouvelle clé, portée, aucun nouveau paramètre ni aucune mise à jour du client n’est requis. Consultez [Configurer la Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-api-access).
</Note>

<Check>
  **Portée requise :** `read:compliance_user_data` sur la Compliance Access Key.

  **Prérequis :** aucun pour lister les sessions à l’échelle de l’organisation. Pour filtrer la liste des sessions distantes (sessions dans le cloud) sur des utilisateurs spécifiques, vous avez besoin des identifiants d’utilisateurs obtenus via [Lister les utilisateurs de l’organisation](https://platform.claude.com/docs/fr/manage-claude/compliance-org-data#list-organization-users) ; la liste des sessions locales ne dispose d’aucun filtre par utilisateur.
</Check>

Les points de terminaison de cette page exposent aux responsables de la conformité les transcriptions de sessions de vos organisations Claude Enterprise. Les transcriptions couvrent les sessions que vos utilisateurs exécutent dans les applications et agents Claude (Cowork, Claude Code, Claude Science, Claude for Microsoft 365, les compléments Claude pour Google Docs, Google Sheets et Google Slides, Claude in Chrome et Claude Tag). Chaque session est une conversation unique avec Claude ; sa transcription est la séquence des prompts de l’utilisateur, des réponses de l’assistant, ainsi que des appels d’outils et de leurs résultats dans cette conversation. Les points de terminaison prennent en charge les exports d’« eDiscovery » (découverte électronique) et l’application de la « data loss prevention » (prévention des pertes de données), ou DLP.

La Compliance API regroupe les sessions en deux familles de points de terminaison selon l’endroit où elles s’exécutent : les points de terminaison de sessions locales pour les sessions sur les machines des utilisateurs, et les points de terminaison de sessions distantes pour les sessions qui s’exécutent dans le cloud, dans des environnements gérés par Anthropic ou, pour Claude Tag, sur un pool de runners auto-hébergé. Les deux familles sont en lecture seule, et aucune n’est accessible aux clés Admin API (`sk-ant-admin01-...`) : les appels authentifiés avec une clé Admin API renvoient [403 Forbidden](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#403-forbidden).

Le tableau suivant associe chaque produit, et l’endroit où il s’exécute, à la famille de points de terminaison qui renvoie ses sessions et à la valeur `product_surface` qui les identifie dans les réponses.

| Produit et lieu d’exécution | Famille de points de terminaison | `product_surface` |
| ----- | ----- | ----- |
| Cowork dans Claude Desktop, s’exécutant sur la machine de l’utilisateur | Points de terminaison de sessions locales (`/v1/compliance/apps/sessions/local`) | `cowork` |
| Claude Code dans le terminal, dans Claude Desktop ou dans une extension d’IDE, s’exécutant sur la machine de l’utilisateur | Points de terminaison de sessions locales | `claude_code` |
| Application de bureau Claude Science, s’exécutant sur la machine de l’utilisateur | Points de terminaison de sessions locales | `claude_science` |
| Claude for Microsoft 365 (les compléments Claude pour Excel, PowerPoint, Word et Outlook), s’exécutant dans les applications de bureau ou web de Microsoft 365 | Points de terminaison de sessions locales | `office_agents/excel`, `office_agents/powerpoint`, `office_agents/word` ou `office_agents/outlook` |
| Les compléments Claude pour Google Docs, Google Sheets et Google Slides, s’exécutant dans ces applications Google | Points de terminaison de sessions locales | `office_agents/google_docs`, `office_agents/google_sheets` ou `office_agents/google_slides` |
| Claude in Chrome (le chat intégré de l’extension de navigateur), s’exécutant sur la machine de l’utilisateur | Points de terminaison de sessions locales | `claude_in_chrome` |
| Sessions Cowork s’exécutant dans le cloud dans des environnements gérés par Anthropic, y compris les sessions démarrées sur claude.ai web ou mobile et les exécutions dans le cloud de tâches planifiées Cowork | Points de terminaison de sessions distantes (`/v1/compliance/apps/sessions/remote`) | `cowork_remote` |
| Sessions [Claude Tag](https://claude.com/docs/claude-tag/overview) démarrées dans Slack, s’exécutant dans le cloud dans des environnements gérés par Anthropic ou sur un pool de runners auto-hébergé | Points de terminaison de sessions distantes | `claude_tag` |

`office_agents` seul n’indique pas de quelle application provient la session, et celle-ci peut provenir de Claude for Microsoft 365 ou des compléments Google. Consultez la description de `product_surface` dans [Sessions sur les machines des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-local-sessions).

La capture des sessions locales est liée à l’activation de la Compliance API pour votre organisation et s’applique tant que les utilisateurs sont connectés avec leur compte Claude Enterprise. Les points de terminaison de sessions ne renvoient pas les éléments suivants :

* Les sessions Claude Code authentifiées avec une clé API Claude Console, ou exécutées via une plateforme cloud tierce telle qu’Amazon Bedrock, Google Cloud ou Microsoft Foundry.
* Les [sessions cloud de Claude Code](https://code.claude.com/docs/en/claude-code-on-the-web) (y compris les [tâches planifiées cloud Claude Code](https://code.claude.com/docs/en/routines)), qui s’exécutent sur une infrastructure cloud plutôt que sur la machine de l’utilisateur. Ces sessions cloud ne sont pas des sessions distantes, même si les deux s’exécutent dans le cloud ; les points de terminaison de sessions distantes renvoient uniquement les sessions Cowork et Claude Tag.
* Les sessions locales provenant de produits autres que Cowork et Claude Code dans les organisations où la [préparation HIPAA](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#hipaa-readiness) est activée. Dans ces organisations, les points de terminaison de sessions locales renvoient uniquement les sessions Cowork et Claude Code, et le contenu des sessions capturées est conservé pendant 30 jours.
* Les sessions locales pour lesquelles la [« zero data retention » (conservation zéro des données), ou ZDR](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#zero-data-retention-zdr-scope), est en vigueur. Ces sessions sont exclues des résultats de liste, et les points de terminaison de récupération et de messages renvoient 404 pour elles.

Anthropic recommande la Compliance API pour récupérer le contenu des sessions. Le tableau suivant compare les [sessions locales](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-local-sessions) et les [sessions distantes](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-remote-sessions) avec les alternatives basées sur OpenTelemetry disponibles pour Cowork et Claude Code, à savoir la [journalisation OpenTelemetry de Cowork](https://support.claude.com/en/articles/14477985-monitor-claude-cowork-activity-with-opentelemetry) et la [surveillance de Claude Code](https://code.claude.com/docs/en/monitoring-usage).

|  | Sessions locales (sur les machines des utilisateurs) | Sessions distantes (dans le cloud) | Journalisation OpenTelemetry |
| ----- | ----- | ----- | ----- |
| Livraison | Pull : requête et export via HTTPS | Pull : requête et export via HTTPS | Push : envoi en streaming vers votre collecteur OTLP |
| Configuration | Fonctionne avec votre Compliance Access Key existante | Fonctionne avec votre Compliance Access Key existante | L’administrateur configure un point de terminaison OTLP et les paramètres de capture du contenu |
| Infrastructure | Hébergée par Anthropic | Hébergée par Anthropic | Vous exploitez le collecteur et le stockage |
| Préfixe d’identifiant | `clls_` | `cse_` | N/A |
| Valeurs de `product_surface` | `cowork`, `claude_code`, `claude_science`, `claude_in_chrome` et les valeurs commençant par `office_agents` | `cowork_remote`, `claude_tag` | N/A |
| Conservation | 6 ans par défaut, ou la période de conservation personnalisée des conversations de votre organisation lorsqu’une période finie est définie ; 30 jours dans les organisations où la préparation HIPAA est activée ; conservées par Anthropic | Aucune période par défaut ; consultez [Conservation et suppression](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retention-and-deletion) ; conservées par Anthropic | Votre infrastructure, vos politiques |
| Prompts de l’utilisateur et réponses de l’assistant | Oui | Oui | Oui, selon les paramètres de capture du contenu |
| Entrées des outils | Tronquées à 10 000 octets par entrée par défaut ; jusqu’à environ 1 Mio sur demande | Tronquées à 10 000 octets par entrée par défaut ; jusqu’à environ 1 Mio sur demande | Résumés tronqués |
| Contenu des résultats d’outils | Chaque entrée texte tronquée à 10 000 octets par défaut ; jusqu’à environ 1 Mio sur demande | Chaque entrée texte tronquée à 10 000 octets par défaut ; jusqu’à environ 1 Mio sur demande | Métadonnées telles que la taille et la réussite ; Claude Code peut également capturer le contenu avec un paramètre facultatif à taille plafonnée |
| Contenu des fichiers | Oui, via les appels d’outils de la transcription (texte uniquement ; les autres contenus apparaissent sous forme d’espace réservé) | Oui, via les appels d’outils de la transcription (texte uniquement ; les autres contenus sont omis) | Chemins de fichiers ; Claude Code peut également capturer le contenu avec un paramètre facultatif à taille plafonnée |
| Métadonnées de l’hôte et de l’appareil (type de terminal, chemins de l’espace de travail) | Non | Non | Oui |
| Utilisation des tokens et coût | Non ; disponibles via la [Claude Enterprise Analytics API](https://platform.claude.com/docs/fr/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api) | Non ; disponibles via la [Claude Enterprise Analytics API](https://platform.claude.com/docs/fr/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api) | Oui |

## Sessions sur les machines des utilisateurs (sessions locales)

Les sessions locales s’exécutent sur les machines des utilisateurs lorsqu’ils sont connectés avec leur compte Claude Enterprise, dans les produits suivants :

* Cowork dans Claude Desktop
* Claude Code (dans le terminal, dans Claude Desktop ou dans une extension d’IDE)
* L’application de bureau Claude Science
* Claude for Microsoft 365 (dans Excel, PowerPoint, Word et Outlook)
* Les compléments Claude pour Google Docs, Google Sheets et Google Slides
* L’extension de navigateur Claude in Chrome

La Compliance API expose les sessions locales via trois points de terminaison : `GET /v1/compliance/apps/sessions/local` liste les métadonnées des sessions, `GET /v1/compliance/apps/sessions/local/{session_id}` récupère les métadonnées d’une session, et `GET /v1/compliance/apps/sessions/local/{session_id}/messages` renvoie la transcription d’une session. Les trois nécessitent la portée `read:compliance_user_data` et ne sont décomptés que de la « rate limit » (limite de débit) partagée de la Compliance API ; ils ne sont pas soumis au second budget de requêtes qui s’applique aux points de terminaison de sessions distantes. Consultez [429 Too Many Requests](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#429-too-many-requests). Si les sessions locales ne sont pas disponibles pour votre organisation parente, les trois points de terminaison renvoient 404 avec le message `Local sessions are not available.` (consultez [Session locale introuvable](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#local-session-not-found)) ; lorsque les listes de sessions ou le contenu capturé sont temporairement indisponibles, ils renvoient 503 (consultez [Sessions locales temporairement indisponibles](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#local-sessions-temporarily-unavailable)).

Pour les sessions locales, Anthropic enregistre chaque conversation côté serveur à mesure que ses requêtes atteignent l’API Claude ; rien n’est installé sur l’appareil, et rien n’est collecté au-delà des requêtes que le client envoie déjà à l’API Claude. Les transcriptions de sessions locales montrent ce qu’il a été demandé à Claude de faire et ce qu’il a renvoyé, et non ce qui s’est produit sur l’appareil. L’activité liée aux fichiers et au réseau n’est visible qu’à travers les appels d’outils et les résultats d’outils dans la transcription ; l’activité qui n’atteint jamais l’API (par exemple, des fichiers locaux que la session n’a jamais envoyés) n’est donc pas capturée.

Dans les organisations qui utilisent des [clés de chiffrement gérées par le client](https://platform.claude.com/docs/fr/manage-claude/cmek), les transcriptions des sessions locales sont chiffrées avec votre clé gérée par le client et renvoyées normalement. Tant que cette clé ne peut pas être utilisée (par exemple, parce que vous l’avez désactivée ou révoquée, ou parce qu’elle est inaccessible), le point de terminaison de messages renvoie [503 Service Unavailable](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#local-sessions-temporarily-unavailable) pour les pages concernées au lieu du contenu de la transcription. Ces messages ne sont jamais signalés comme `not_captured` (consultez [Récupérer la transcription d’une session locale](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-a-local-session-transcript)). Le listage des sessions et la récupération des métadonnées de session ne sont pas affectés.

Le point de terminaison de liste renvoie les métadonnées des sessions, sans contenu de transcription, pour chaque organisation liée que votre clé peut lire. Contrairement à la liste des sessions distantes, il ne dispose d’aucun filtre par organisation ou par utilisateur : délimitez les résultats dans le temps avec `created_at.gte`, `created_at.gt`, `created_at.lt` et `created_at.lte`. Chacun accepte un horodatage RFC 3339 avec un décalage UTC obligatoire. Lorsque vous fournissez à la fois une borne inférieure et une borne supérieure, la borne supérieure doit être postérieure à la borne inférieure (ou égale à celle-ci, si vous utilisez `created_at.gte` avec `created_at.lte`), faute de quoi la requête renvoie [400 Bad Request](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#400-bad-request). Un filtre temporel distinct, `updated_at.gte`, délimite selon la dernière activité plutôt que la première : il renvoie les sessions dont le dernier appel d’inférence a lieu à l’heure indiquée ou après, et se combine avec les filtres `created_at` sans modifier l’ordre ni la pagination. Utilisez-le pour interroger périodiquement les sessions actives depuis un passage précédent, comme décrit plus loin dans cette section. Les nouvelles sessions et les nouveaux messages apparaissent dans les résultats après un court délai de traitement, généralement de quelques minutes ; une session absente immédiatement après son démarrage n’est pas nécessairement non capturée. La requête suivante liste les sessions créées depuis une date donnée.

```bash cURL
curl --fail-with-body -sS -G \
  "https://api.anthropic.com/v1/compliance/apps/sessions/local" \
  -H "x-api-key: $ANTHROPIC_COMPLIANCE_ACCESS_KEY" \
  -H "anthropic-version: 2026-10-21" \
  --data-urlencode "created_at.gte=2026-07-01T00:00:00Z" \
  --data-urlencode "limit=100"
```

```json Response
{
  "data": [
    {
      "type": "compliance_local_session",
      "id": "clls_01HxKpLmNoPqRsTuVwXyZaBc",
      "organization_uuid": "9a1e0000-0000-0000-0000-000000000000",
      "workspace_id": "wrkspc_01SvYKoWVRVHoEbwESNvzYdR",
      "user": {
        "id": "user_01GpKpLmNoPqRsTuVwXyZaBc",
        "email_address": "engineer@example.com"
      },
      "product_surface": "cowork",
      "created_at": "2026-07-09T14:02:11Z",
      "updated_at": "2026-07-09T14:02:38Z"
    },
    {
      "type": "compliance_local_session",
      "id": "clls_01HyLqMnOpQrStUvWxYzAbCd",
      "organization_uuid": "9a1e0000-0000-0000-0000-000000000000",
      "workspace_id": null,
      "user": {
        "id": "user_01HqRsTuVwXyZaBcDeFgHiJk",
        "email_address": null
      },
      "product_surface": "claude_code",
      "created_at": "2026-07-08T09:15:43Z",
      "updated_at": "2026-07-08T09:52:10Z"
    }
  ],
  "next_page": "page_AAEfQx7mPdLkq9Rt2VwHbZk"
}
```

Les résultats sont triés par ordre chronologique inverse (les plus récents en premier) selon `created_at`, les égalités étant départagées selon un ordre fixe côté serveur, et plafonnés à `limit` résultats par réponse (100 par défaut, 500 maximum). Le point de terminaison pagine uniquement vers l’avant avec les jetons `page` et `next_page` (consultez [Paginer les résultats](https://platform.claude.com/docs/fr/manage-claude/compliance-activity-feed#paginate-results)) : renvoyez la valeur `next_page` de la réponse comme paramètre de requête `page` lors de la requête suivante, et arrêtez-vous lorsque `next_page` vaut `null`. La réponse n’a pas de champ `has_more`. Terminez un parcours de liste dans les 24 heures suivant son début ; un curseur de liste plus ancien est toujours accepté mais est réévalué par rapport à la limite de conservation actuelle, de sorte que les sessions dont l’activité conservée la plus ancienne est sur le point de dépasser la période de conservation peuvent être ignorées.

Dans chaque objet session, `user.id` est toujours défini et persiste après la suppression du compte ; `user.email_address` vaut `null` lorsque le compte de l’utilisateur a été supprimé ou que l’utilisateur n’est plus membre d’une organisation que votre clé peut lire. `workspace_id` vaut `null` lorsque la session n’était pas associée à un espace de travail. Une session locale correspond à un identifiant de session client : ouvrir une nouvelle conversation dans le client, ou effacer son contexte, démarre un nouvel enregistrement de session. Pour Claude Science, la liste peut également inclure des sessions distinctes pour le travail en arrière-plan propre à l’application (par exemple, le nommage de la conversation ; sur les versions plus récentes de l’application, également ses pistes de révision et de délégation), et sur les versions plus anciennes de l’application, une partie de ce travail en arrière-plan apparaît sous forme de messages supplémentaires dans la transcription de la conversation elle-même. Une conversation Claude Science qui se poursuit à travers certaines mises à jour de l’application apparaît sous forme de deux sessions. Ces comportements sont attendus. Traitez les valeurs `id` comme des chaînes opaques ; le format peut changer sans préavis.

Pour Claude for Microsoft 365 et les compléments Claude pour Google Docs, Google Sheets et Google Slides, la suppression d’une conversation dans le complément n’a lieu que sur le client ; elle n’est donc pas reflétée dans l’API : les sessions locales n’ont pas de champ `deleted_at`, et la session reste listée jusqu’à ce que la conservation la supprime.

Les sessions locales comportent un `updated_at` mais pas de `status` : une session locale n’a pas de statut de cycle de vie côté serveur, et sa visibilité est régie par la conservation. Une session locale est capturée sous la forme de la série d’appels à l’API Claude (appels d’inférence) que le client effectue pendant la session, et la conservation s’applique individuellement à chaque appel capturé. `created_at` est l’horodatage de l’appel conservé le plus ancien de la session et `updated_at` celui de son dernier appel, tous deux en UTC. À mesure que les appels plus anciens dépassent la période de conservation, `created_at` avance en conséquence, et une fois que tous les appels d’une session ont expiré, la session n’est plus renvoyée ; `updated_at` suit l’appel le plus récent et n’est pas affecté jusque-là. Comme `created_at` peut changer d’une exécution à l’autre, dédupliquez sur `id` lorsque vous parcourez à nouveau la liste au fil du temps. Pour maintenir les transcriptions à jour à mesure que les sessions reçoivent de nouveaux messages, interrogez périodiquement avec le filtre `updated_at.gte`, en faisant se chevaucher les fenêtres consécutives. Sur le point de terminaison de liste, `updated_at` est une borne inférieure : pour une session encore active à la limite d’une page ou à l’extrémité supérieure d’une fenêtre `created_at`, il peut momentanément être en retard sur la dernière activité réelle de la session, et un nouvel appel ne devient interrogeable qu’après le court délai de traitement mentionné précédemment. En raison de ce décalage, définissez le `updated_at.gte` de chaque exécution quelques minutes avant l’heure de début de votre exécution précédente, et non exactement à l’heure de l’exécution précédente. Une borne définie exactement à l’heure précédente écarte silencieusement et définitivement une session dont le dernier appel était encore en cours d’indexation à ce moment-là, car une fois que la borne a dépassé cet appel, aucune exécution ultérieure ne le renvoie. Dédupliquez les sessions renvoyées sur `id`, récupérez à nouveau leurs transcriptions et dédupliquez les messages sur `id`. La récupération d’une session, ou de ses messages, reflète toujours exactement le dernier appel conservé ; un passage de réconciliation périodique sur une fenêtre plus ancienne constitue donc une alternative plus exhaustive à l’élargissement du chevauchement.

La liste n’inclut que les sessions comportant au moins un appel capturé. Une session terminée avant le début de la capture pour votre organisation n’est pas listée. Pour une session déjà en cours à ce moment-là, `created_at` correspond à l’heure de son premier appel capturé. Certains messages d’une session listée peuvent néanmoins être marqués comme indisponibles, par exemple parce que les politiques de traitement des données d’Anthropic retiennent leur contenu (consultez [Récupérer la transcription d’une session locale](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-a-local-session-transcript)).

Le contenu capturé des sessions locales est conservé pendant 6 ans à compter de la capture par défaut. Si l’organisation qui a exécuté la session a défini une période de conservation personnalisée finie des conversations dans [claude.ai > Paramètres de l’organisation > Données et confidentialité](https://claude.ai/admin-settings/data-privacy-controls), cette période s’applique à la place, qu’elle soit plus courte ou plus longue que la valeur par défaut. Seule une période définie pour les chats ou pour toutes les données s’applique ; les périodes définies pour les projets ou les Artifacts n’affectent pas les sessions locales. Une modification de cette période prend effet de deux manières différentes : les points de terminaison cessent de renvoyer l’activité antérieure à la période actuelle de l’organisation dès que le paramètre change, tandis que chaque message capturé est conservé pendant la période en vigueur au moment de sa capture ; allonger la période ultérieurement ne restaure donc pas le contenu déjà expiré. Dans les organisations où la [préparation HIPAA](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention#hipaa-readiness) est activée, le contenu capturé des sessions locales est conservé pendant 30 jours à compter de la capture, ou pendant la période de conservation personnalisée des conversations de l’organisation lorsque celle-ci est plus courte ; la valeur par défaut de 6 ans ne s’applique pas.

Pour récupérer directement les métadonnées d’une session, transmettez son identifiant à `GET /v1/compliance/apps/sessions/local/{session_id}`. La réponse est le même objet session que celui renvoyé par le point de terminaison de liste, sans enveloppe et sans contenu de transcription. Un identifiant de session mal formé renvoie [400 Bad Request](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#400-bad-request). Une seule erreur [404 Not Found](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#404-not-found) couvre quatre cas que la réponse ne distingue pas :

* La session n’appartient pas à une organisation que votre clé peut lire (y compris les sessions relevant d’une autre organisation parente).
* La session n’existe pas.
* La conservation zéro des données est en vigueur pour la session.
* Tous les appels de la session ont dépassé la période de conservation.

`product_surface` (chaîne ou `null`) vous indique de quel produit provient la session. Il vaut `null` si le produit n’a pas été enregistré. Sinon, il prend l’une de ces valeurs :

* `cowork` : Cowork dans Claude Desktop sur la machine de l’utilisateur
* `claude_code` : Claude Code
* `claude_science` : Claude Science
* `claude_in_chrome` : le chat intégré de l’extension de navigateur Claude in Chrome
* `office_agents/excel`, `office_agents/powerpoint`, `office_agents/word` ou `office_agents/outlook` : Claude for Microsoft 365 dans Excel, PowerPoint, Word ou Outlook
* `office_agents/google_docs`, `office_agents/google_sheets` ou `office_agents/google_slides` : le complément Claude pour Google Docs, Google Sheets ou Google Slides
* `office_agents` : Claude for Microsoft 365 ou l’un des compléments Google, lorsque l’application n’a pas été enregistrée

Si une session affiche `office_agents` seul, rien d’autre dans la réponse ne vous indique duquel de ces produits elle provient. Ne supposez pas qu’il s’agit de Claude for Microsoft 365.

La valeur provient de l’activité la plus récente de la session ; elle peut donc changer au fil du temps. L’API a commencé à enregistrer les valeurs Google le 5 octobre 2026. Une session de complément Google dont l’activité la plus récente a eu lieu à cette date ou avant peut afficher `office_agents`. Si l’utilisateur travaille à nouveau dans cette session, la valeur passe à la valeur Google correspondante.

<Note>
  **Concevez des gestionnaires compatibles avec les évolutions futures.** Laissez passer les valeurs `product_surface` non reconnues et ignorez les champs que votre gestionnaire n’attend pas, afin que votre intégration continue de fonctionner à mesure que de nouvelles surfaces de produit sont lancées.
</Note>

### Récupérer la transcription d’une session locale

Le point de terminaison de messages renvoie la transcription de la session, reconstruite à partir des appels à l’API Claude capturés : prompts de l’utilisateur, texte de l’assistant, appels d’outils et parties textuelles des résultats d’outils, tous renvoyés tels qu’ils ont été envoyés, à l’exception de la troncature liée à la taille. Rien ne masque les URL, les identifiants ou les données personnelles dans ce contenu ; traitez donc les transcriptions comme sensibles. La transcription omet ou remplace les éléments suivants :

* Les blocs de réflexion ne sont jamais inclus.
* Le « system prompt » (invite système) de la requête n’est jamais renvoyé. Un message marqueur indiquant `[system prompt content not shown]` le remplace (normalement une fois par session ; une session sans contenu disponible ne comporte aucun marqueur).
* Les définitions d’outils et la configuration des serveurs « Model Context Protocol », ou MCP, ne font pas partie de la transcription.
* Les images, les PDF et les autres blocs binaires ou structurés ne sont pas renvoyés. Chacun apparaît sous la forme d’un bloc `text` indiquant `[<block type> content not shown]` (par exemple, `[image content not shown]`) avec `truncated` défini sur `true`. Les éléments non textuels à l’intérieur d’un résultat d’outil, tels que les résultats de [recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool) ou la sortie de l’[outil d’exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool), sont remplacés par une entrée `[N non-text item(s) not shown]`, et le `truncated` du bloc de résultat d’outil vaut `true`. L’appel d’outil correspondant, avec la requête de recherche ou le code dans son `input`, est toujours renvoyé.
* Les métadonnées de citation sur les blocs `text`, telles que les citations de sources d’une réponse s’appuyant sur des résultats de recherche web, sont omises. Le texte lui-même est renvoyé, et le bloc comporte `truncated` défini sur `true`.

Les fichiers d’instructions de projet tels que `CLAUDE.md` apparaissent comme du contenu ordinaire de rôle utilisateur. Le contenu des Skills apparaît lorsque le client l’envoie comme contenu de message et n’est pas distingué des autres textes de l’utilisateur. Pour un résumé de la couverture, consultez la [FAQ de la Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-faq#data-coverage-and-retention) ; pour un tableau comparant les sessions locales aux sessions distantes et à la journalisation OpenTelemetry, consultez l’introduction de cette page.

```bash cURL
curl --fail-with-body -sS \
  "https://api.anthropic.com/v1/compliance/apps/sessions/local/clls_01HxKpLmNoPqRsTuVwXyZaBc/messages" \
  -H "x-api-key: $ANTHROPIC_COMPLIANCE_ACCESS_KEY" \
  -H "anthropic-version: 2026-10-21"
```

```json Response
{
  "session": {
    "type": "compliance_local_session",
    "id": "clls_01HxKpLmNoPqRsTuVwXyZaBc",
    "organization_uuid": "9a1e0000-0000-0000-0000-000000000000",
    "workspace_id": "wrkspc_01SvYKoWVRVHoEbwESNvzYdR",
    "user": {
      "id": "user_01GpKpLmNoPqRsTuVwXyZaBc",
      "email_address": null
    },
    "product_surface": "cowork",
    "created_at": "2026-07-09T14:02:11Z",
    "updated_at": "2026-07-09T14:02:38Z"
  },
  "data": [
    {
      "type": "compliance_local_session_message",
      "id": "clsm_01J4KpLmNoPqRsTuVwXyZaBa",
      "role": "user",
      "model": null,
      "created_at": "2026-07-09T14:02:11Z",
      "provenance": {
        "type": "synthetic_marker"
      },
      "content": [
        {
          "type": "text",
          "text": "[system prompt content not shown]",
          "truncated": true
        }
      ]
    },
    {
      "type": "compliance_local_session_message",
      "id": "clsm_01J4KpLmNoPqRsTuVwXyZaBc",
      "role": "user",
      "model": null,
      "created_at": "2026-07-09T14:02:11Z",
      "provenance": null,
      "content": [
        {
          "type": "text",
          "text": "Fix the failing test in tests/auth_test.py",
          "truncated": false
        }
      ]
    },
    {
      "type": "compliance_local_session_message",
      "id": "clsm_01J4KpLmNoPqRsTuVwXyZaBd",
      "role": "assistant",
      "model": "claude-opus-5-5",
      "created_at": "2026-07-09T14:02:11Z",
      "provenance": null,
      "content": [
        {
          "type": "text",
          "text": "I'll read the test file first.",
          "truncated": false
        },
        {
          "type": "tool_use",
          "id": "toolu_01AbCdEfGhIjKlMnOpQrSt",
          "name": "Read",
          "input": "{\"file_path\":\"tests/auth_test.py\"}",
          "truncated": false
        }
      ]
    },
    {
      "type": "compliance_local_session_message",
      "id": "clsm_01J4KpLmNoPqRsTuVwXyZaBe",
      "role": "user",
      "model": null,
      "created_at": "2026-07-09T14:02:38Z",
      "provenance": null,
      "content": [
        {
          "type": "tool_result",
          "tool_use_id": "toolu_01AbCdEfGhIjKlMnOpQrSt",
          "name": "Read",
          "is_error": false,
          "content": [
            {
              "type": "text",
              "text": "def test_login_expiry():\n    ..."
            }
          ],
          "truncated": false
        }
      ]
    },
    {
      "type": "compliance_local_session_message",
      "id": "clsm_01J4KpLmNoPqRsTuVwXyZaBf",
      "role": "assistant",
      "model": "claude-opus-5-5",
      "created_at": "2026-07-09T14:02:38Z",
      "provenance": null,
      "content": [
        {
          "type": "text",
          "text": "The test was asserting on a stale expiry timestamp. I've updated it.",
          "truncated": false
        }
      ]
    }
  ],
  "next_page": null
}
```

La réponse intègre une enveloppe `session` à côté du tableau paginé `data`. Le premier enregistrement de cet exemple est le marqueur qui remplace l’invite système de la requête ; sa `provenance` est décrite plus loin dans cette section. Sur ce point de terminaison, `user.email_address` vaut toujours `null` : le point de terminaison de messages ne résout pas les adresses e-mail ; un `null` ici ne signifie donc pas que le compte de l’utilisateur a été supprimé. Pour attribuer une session à une adresse e-mail, faites une jointure de `user.id` avec le [point de terminaison de liste](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-local-sessions) ou le point de terminaison de récupération (`GET /v1/compliance/apps/sessions/local/{session_id}`).

Les messages sont renvoyés du plus ancien au plus récent par défaut ; transmettez `order=desc` pour inverser l’ordre. La pagination utilise le même schéma `page`/`next_page` que le point de terminaison de liste, avec une valeur `limit` de 100 par défaut et de 1 000 au maximum. Une page peut se terminer prématurément lorsque la réponse atteint sa limite de taille ; une page comportant moins de `limit` messages ne signifie donc pas que vous avez atteint la fin ; continuez à paginer jusqu’à ce que `next_page` vaille `null`. Les curseurs de page sont liés à la session et à l’ordre de tri sous lesquels ils ont été émis, et les curseurs d’un parcours expirent 24 heures après sa première page : un curseur expiré renvoie [400 Bad Request](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#400-bad-request) en vous indiquant de recommencer sans le paramètre `page`, et le parcours relancé reflète la limite de conservation actuelle. Un curseur émis pour une autre session ou un autre `order` renvoie également 400, en tant que curseur invalide.

Sur une session très volumineuse, le point de terminaison de messages peut renvoyer une erreur 400 pour une page, avec un message indiquant que la page est trop volumineuse pour être lue ; consultez [Page de transcription trop volumineuse](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#transcript-page-too-large). Ne relancez pas cette requête. Si elle utilisait `order=desc`, lisez plutôt cette session du plus ancien au plus récent à partir de sa première page, sans `order` ni `page`, et définissez le délai d’expiration des requêtes de votre client à au moins 5 minutes. Si une page lue du plus ancien au plus récent renvoie la même erreur, l’entrée correspondante du guide des erreurs indique la marche à suivre.

Sur une session très volumineuse, le point de terminaison de messages peut également renvoyer une erreur 429 dont le `error.details.error_code` vaut `transcript_read_server_busy`. Cela ne signifie pas que votre organisation a dépassé une limite de débit. Contrairement à l’erreur 400, relancez-la : attendez le nombre de secondes indiqué dans l’en-tête `retry-after`, puis renvoyez la même requête, sans modification (avec la même valeur `page`, le cas échéant). Consultez [Serveur occupé à lire des transcriptions volumineuses](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#server-busy-reading-large-transcripts).

Chaque message comporte un `role` (`user` ou `assistant`) et un tableau `content` de blocs `text`, `tool_use` et `tool_result`. Il comporte également un `model` : sur un tour de l’assistant capturé depuis l’API Claude, il s’agit du modèle qui a servi ce tour. Le `model` vaut `null` sur les messages utilisateur et sur tout message de l’assistant dont la `provenance` est définie, car l’historique affirmé par le client et les marqueurs synthétiques n’ont pas été produits par un modèle, et le modèle ayant servi est inconnu pour le contenu indisponible. Un bloc `text` comporte `text` et `truncated`. Un bloc `tool_use` comporte `id`, `name`, `input` et `truncated`, où `input` est une chaîne encodée en JSON plutôt qu’un objet. Un bloc `tool_result` comporte `tool_use_id`, `name`, `is_error`, un tableau `content` d’entrées `text`, et `truncated`. Les appels et résultats d’outils MCP, ainsi que la plupart des appels et résultats d’outils serveur, sont normalisés dans ces mêmes formes `tool_use` et `tool_result` ; tout autre type de bloc apparaît sous forme d’espace réservé `[<block type> content not shown]`. L’`id` d’un message est stable tant que le tour est conservé. Chaque message reconstruit à partir du même appel d’inférence porte l’horodatage de cet appel ; des messages consécutifs partagent donc souvent une même valeur `created_at` ; conservez l’ordre renvoyé plutôt que de retrier par horodatage.

Chaque message comporte également un champ `provenance` décrivant la manière dont son contenu a été capturé. `provenance` vaut `null` pour le contenu vérifié capturé par l’API Claude, ce qui est le cas courant. Sinon, il s’agit d’un objet dont le `type` signale l’exception :

* `content_unavailable` signifie que le contenu ne peut pas être renvoyé. Le tableau `content` est vide, et `provenance.reason` en indique la raison. `not_captured` signifie qu’aucun contenu n’est disponible pour le tour. Cela ne prouve pas qu’aucun enregistrement n’a été stocké : le contenu que les politiques de traitement des données d’Anthropic excluent de la Compliance API est signalé avec la même raison, de même que les tours individuels, au sein d’une session par ailleurs capturée, qui sont indisponibles pour de telles raisons. Une clé gérée par le client inutilisable constitue la seule exception et renvoie plutôt [503 Service Unavailable](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#local-sessions-temporarily-unavailable). `client_aborted` signifie que le client a fermé la connexion ou annulé la requête avant la fin de la réponse ; la réponse du tour n’a donc pas été capturée ; toute sortie partielle déjà diffusée en streaming vers le client n’est pas incluse, et cette raison s’applique uniquement aux tours du rôle assistant. `cmek_key_revoked` est réservé au contenu chiffré avec la clé gérée par le client de votre organisation lorsque cette clé est indisponible (par exemple, révoquée). Cette valeur n’est pas renvoyée actuellement, car une clé inutilisable produit plutôt une erreur 503, mais gérez-la pour assurer la compatibilité future. `retention_elapsed` signifie que le contenu a dépassé la période de conservation. `oversize` signifie qu’un message individuel a dépassé la limite de taille par message ; le message est tout de même renvoyé, avec un tableau `content` vide.
* `client_asserted` signale les messages de l’assistant que le client a fournis comme historique de conversation et qui n’ont pas pu être associés à une réponse capturée ; leur paternité n’est pas vérifiée.
* `synthetic_marker` signale les enregistrements générés par le point de terminaison lui-même, tels que le marqueur qui remplace l’invite système. Lorsque le client réécrit ou compacte son historique de conversation en cours de session (par exemple, après une compaction du contexte), la transcription insère un message marqueur à cet endroit et se poursuit avec le nouveau contenu envoyé par le client. Lorsque votre organisation dispose d’une période de conservation finie et que ce nouveau contenu inclut des messages de l’assistant, la transcription masque le nouveau contenu jusqu’à son dernier message de l’assistant inclus (un second marqueur le signale) et n’affiche que les messages de l’utilisateur postérieurs à ce point, suivis du reste de la session.

Les messages marqueurs et les messages affirmés par le client commencent par un bloc `text` explicatif entre crochets marqué `truncated: true`, par exemple `[system prompt content not shown]`. Traitez ces enregistrements comme présents mais indisponibles ou non vérifiés plutôt que manquants, et tolérez les types et raisons de `provenance` non reconnus.

Deux paramètres plafonnent le nombre d’octets renvoyés pour chaque bloc d’outil : `tool_use_input_max_bytes` et `tool_result_max_bytes`, tous deux fixés par défaut à 10 000 octets. Transmettez `-1` pour le maximum du serveur (environ 1 Mio pour chaque chaîne) ; `0` renvoie [400 Bad Request](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#400-bad-request), et les valeurs supérieures au maximum sont ramenées à celui-ci. Une chaîne coupée par l’un ou l’autre plafond est coupée à une limite de caractère et se voit ajouter un suffixe intégré (par exemple, `…[truncated; pass tool_result_max_bytes=-1 for the server max]`), et son bloc porte `"truncated": true`. Un `input` de `tool_use` tronqué n’est donc plus du JSON valide ; n’analysez donc les entrées d’outils qu’à partir de blocs non tronqués (ou augmentez le plafond et récupérez-les à nouveau). Les blocs de type `text` sont toujours plafonnés au même maximum du serveur d’environ 1 Mio ; aucun paramètre ne permet de l’augmenter, et un bloc `text` atteignant cette limite porte également `"truncated": true`.

Claude Science appelle les connecteurs (serveurs MCP) depuis du code qu’il exécute via son outil `repl`, et non en tant qu’outils nommés séparément ; aucun bloc d’une transcription Claude Science ne porte donc le nom d’un connecteur. Chaque appel de connecteur apparaît dans le code à l’intérieur de l’`input` d’un bloc `tool_use` `repl` (par exemple, un appel `host.mcp("<server>", "<tool>", ...)`), et la sortie du connecteur n’apparaît dans le `tool_result` correspondant que là où ce code l’a affichée. Les sessions Cowork et Claude Code diffèrent : elles appellent chaque outil de connecteur sous son propre nom `mcp__<server>__<tool>`, qui est le `name` du bloc `tool_use`. Pour surveiller l’utilisation des connecteurs dans les sessions Claude Science, analysez la chaîne `input` et effectuez la correspondance sur le code qu’elle contient plutôt que sur un nom d’outil. Transmettez `tool_use_input_max_bytes=-1` pour ces sessions afin qu’une longue entrée de code soit renvoyée jusqu’au maximum du serveur au lieu d’être coupée à la valeur par défaut de 10 000 octets avant l’apparition de l’appel de connecteur.

Le contenu des transcriptions respecte la période de conservation décrite dans [Sessions sur les machines des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-local-sessions). Lorsque les appels les plus anciens d’une session ont dépassé cette période, la transcription commence par un unique espace réservé `content_unavailable` avec une `reason` de `retention_elapsed`, suivi des messages conservés. Lorsque tous les appels d’une session ont expiré, le point de terminaison de messages renvoie [404 Not Found](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#404-not-found), comme il le fait pour les sessions d’organisations que votre clé ne peut pas lire, les sessions qui n’existent pas et les sessions pour lesquelles la conservation zéro des données est en vigueur. Un identifiant de session mal formé renvoie [400 Bad Request](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#400-bad-request).

## Sessions dans le cloud (sessions distantes)

Les sessions Cowork démarrées sur claude.ai web ou mobile et les sessions Claude Tag démarrées dans Slack s’exécutent dans le cloud, dans des environnements gérés par Anthropic ; les sessions Claude Tag peuvent également s’exécuter sur un pool d’exécuteurs auto-hébergé. La Compliance API expose ces sessions distantes via deux points de terminaison : `GET /v1/compliance/apps/sessions/remote` liste les métadonnées des sessions, et `GET /v1/compliance/apps/sessions/remote/{session_id}/messages` renvoie la transcription d’une session. Les deux nécessitent la portée `read:compliance_user_data`, et les deux sont décomptés de la « rate limit » (limite de débit) partagée de la Compliance API ainsi que d’un second budget de requêtes propre à ces points de terminaison ; consultez [429 Too Many Requests](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#429-too-many-requests).

Le point de terminaison de liste porte par défaut sur l’ensemble de l’organisation : omettez `organization_ids[]` pour inclure toutes les organisations claude.ai que votre clé peut lire, ou transmettez jusqu’à 500 valeurs pour restreindre la portée. Pour limiter plutôt la liste à des utilisateurs spécifiques, transmettez de 1 à 10 valeurs `user_ids[]` (obtenez les identifiants via [Lister les utilisateurs de l’organisation](https://platform.claude.com/docs/fr/manage-claude/compliance-org-data#list-organization-users)) ; le filtre correspond à l’utilisateur propriétaire de la session, de sorte que les sessions appartenant à un agent, y compris les sessions Claude Tag appartenant à un agent, sont exclues dès que `user_ids[]` est défini. Bornez les résultats dans le temps avec les paramètres de plage `created_at` (`gte`, `gt`, `lt`, `lte`, au format RFC 3339). Il n’existe pas de filtre `updated_at`. La requête suivante liste les sessions créées depuis une date donnée.

```bash cURL
curl --fail-with-body -sS -G \
  "https://api.anthropic.com/v1/compliance/apps/sessions/remote" \
  -H "x-api-key: $ANTHROPIC_COMPLIANCE_ACCESS_KEY" \
  -H "anthropic-version: 2026-10-21" \
  --data-urlencode "created_at.gte=2026-06-01T00:00:00Z" \
  --data-urlencode "limit=100"
```

```json Response
{
  "data": [
    {
      "id": "cse_01WpQrStUvXyZaBcDeFgHjK6",
      "organization_uuid": "91012d09-e48b-438e-a489-1bebfd8fa6f9",
      "user": {
        "id": "user_01WxYzAbCdEfGhJkMnPqRsTu",
        "email_address": "user@example.com"
      },
      "agent_id": null,
      "started_by_user": null,
      "status": "active",
      "created_at": "2026-07-01T17:04:05Z",
      "updated_at": "2026-07-01T18:00:41Z",
      "product_surface": "cowork_remote",
      "claude_project_id": "claude_proj_01KGp4eZNug9ri4kE35RSppq"
    },
    {
      "id": "cse_01TkNpRsUvWxYzAbCdEfGhJ4",
      "organization_uuid": "91012d09-e48b-438e-a489-1bebfd8fa6f9",
      "user": {
        "id": "user_01WxYzAbCdEfGhJkMnPqRsTu",
        "email_address": "user@example.com"
      },
      "agent_id": null,
      "started_by_user": null,
      "status": "archived",
      "created_at": "2026-06-28T09:15:22Z",
      "updated_at": "2026-06-28T09:47:10Z",
      "product_surface": "cowork_remote",
      "claude_project_id": null
    }
  ],
  "next_page": "page_AAEfMk93cXpYdGxrZXk"
}
```

Les résultats sont triés par ordre chronologique inverse (les plus récents en premier) selon `created_at` et plafonnés à `limit` résultats par réponse (100 par défaut, 500 au maximum). Le point de terminaison pagine avec les jetons `page` et `next_page` (consultez [Paginer les résultats](https://platform.claude.com/docs/fr/manage-claude/compliance-activity-feed#paginate-results)) : renvoyez la valeur `next_page` de la réponse comme paramètre de requête `page` lors de la requête suivante, et arrêtez-vous lorsque `next_page` vaut `null`.

Une session appartient soit à un utilisateur, soit à un agent, jamais aux deux. Pour les sessions appartenant à un utilisateur, `user` contient l’identifiant et l’adresse e-mail du propriétaire (`email_address` vaut `null` lorsque l’utilisateur n’est plus membre d’une organisation que votre clé peut lire) et `agent_id` vaut `null`. Pour les sessions appartenant à un agent (par exemple, une session Claude Tag démarrée par une mention dans Slack), `user` vaut `null` et `agent_id` contient l’identifiant de l’agent (préfixe `cagt_`). Sur ces sessions, `started_by_user` identifie la personne qui a démarré la session, lorsqu’une telle personne est enregistrée ; il peut donc valoir `null` sur une session Claude Tag. Sur les sessions appartenant à un utilisateur, `started_by_user` vaut `null`.

Chaque exécution d’une tâche planifiée Cowork dans le cloud a lieu dans une session qui a le même propriétaire que la tâche. Lorsqu’un utilisateur crée la tâche dans Cowork, ces sessions appartiennent à cet utilisateur : `user` identifie cet utilisateur, et `agent_id` et `started_by_user` valent `null`. Un filtre `user_ids[]` qui désigne cet utilisateur correspond à ces sessions. Une exécution peut démarrer une nouvelle session ou poursuivre une session existante. Lorsqu’une exécution poursuit une session existante, le `created_at` de cette session correspond au moment où la session a commencé, et non au moment où l’exécution a eu lieu. Aucun champ de session n’identifie une session comme une exécution planifiée ni ne contient le nom ou la planification de la tâche.

`claude_project_id` est l’identifiant du [projet](https://platform.claude.com/docs/fr/manage-claude/compliance-content-data#retrieve-projects-and-attachments) claude.ai auquel appartient la session (préfixe `claude_proj_`), ou `null` lorsque la session ne fait pas partie d’un projet.

`status` prend l’une des valeurs `pending`, `active`, `paused`, `archived` ou `failed`. Une session est `pending` pendant son provisionnement ; une session `pending` n’a pas encore de transcription, et le point de terminaison des messages renvoie 404 pour celle-ci jusqu’à la fin du provisionnement. Les sessions supprimées ne sont jamais renvoyées.

`product_surface` (chaîne ou `null`) identifie le produit qui a créé la session. Le point de terminaison renvoie actuellement les sessions ayant l’une de deux valeurs `product_surface`. `cowork_remote` correspond aux sessions Cowork dans le cloud, y compris les sessions démarrées sur claude.ai web ou mobile et les exécutions dans le cloud de tâches planifiées Cowork. `claude_tag` correspond aux sessions Claude Tag démarrées dans Slack.

Pour récupérer un chat dans l’expérience Claude unifiée, y compris la partie exécutée dans le cloud, utilisez les points de terminaison de chats ([Obtenir les messages d’un chat](https://platform.claude.com/docs/fr/api/compliance/apps/chats/messages/list)), et non les points de terminaison de sessions distantes. La liste des sessions distantes renvoie également les sessions dans lesquelles un tel chat se poursuit, sous la valeur `cowork_remote` ; un export portant à la fois sur les chats et sur les sessions distantes contient donc ce travail en double.

<Note>
  **Concevez des gestionnaires compatibles avec les évolutions futures.** Laissez passer les valeurs `status` et `product_surface` non reconnues, et ignorez les champs que votre gestionnaire n’attend pas, afin que votre intégration continue de fonctionner à mesure que de nouveaux statuts et de nouvelles surfaces produit sont publiés.
</Note>

### Récupérer la transcription d’une session distante

Le point de terminaison des messages renvoie la transcription de la session : les prompts de l’utilisateur, les réponses de l’assistant, ainsi que les « tool calls » (appels d’outils) et leurs résultats. Les blocs de réflexion et les images ne sont pas inclus. Pour un résumé de la couverture, consultez la [FAQ de la Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-faq#data-coverage-and-retention) ; pour un tableau comparant les sessions distantes aux sessions locales et à la journalisation OpenTelemetry de Cowork, consultez l’introduction de cette page.

```bash cURL
curl --fail-with-body -sS \
  "https://api.anthropic.com/v1/compliance/apps/sessions/remote/cse_01WpQrStUvXyZaBcDeFgHjK6/messages" \
  -H "x-api-key: $ANTHROPIC_COMPLIANCE_ACCESS_KEY" \
  -H "anthropic-version: 2026-10-21"
```

```json Response
{
  "session": {
    "id": "cse_01WpQrStUvXyZaBcDeFgHjK6",
    "organization_uuid": "91012d09-e48b-438e-a489-1bebfd8fa6f9",
    "user": {
      "id": "user_01WxYzAbCdEfGhJkMnPqRsTu",
      "email_address": null
    },
    "agent_id": null,
    "started_by_user": null,
    "status": "active",
    "created_at": "2026-07-01T17:04:05Z",
    "updated_at": "2026-07-01T18:00:41Z",
    "product_surface": "cowork_remote",
    "claude_project_id": null
  },
  "data": [
    {
      "id": "csev_01HjKmNpQrStUvWxYzAbCdE2",
      "role": "user",
      "created_at": "2026-07-01T17:04:05Z",
      "content": [
        {
          "type": "text",
          "text": "Summarize the customer feedback in the attached spreadsheet.",
          "truncated": false
        }
      ],
      "sent_by_user_id": null,
      "content_unavailable": false
    },
    {
      "id": "csev_01BcDeFgHjKmNpQrStUvWxY4",
      "role": "assistant",
      "created_at": "2026-07-01T17:04:06Z",
      "content": [
        {
          "type": "text",
          "text": "I'll start by reading the spreadsheet...",
          "truncated": false
        }
      ],
      "sent_by_user_id": null,
      "content_unavailable": false
    }
  ],
  "next_page": null
}
```

La réponse intègre une enveloppe `session` à côté du tableau paginé `data`. Sur ce point de terminaison, `user.email_address`, `started_by_user` et `claude_project_id` valent toujours `null` dans l’enveloppe. Obtenez plutôt ces valeurs à partir du point de terminaison de liste.

Par défaut, les messages sont renvoyés du plus ancien au plus récent ; transmettez `order=desc` pour inverser l’ordre. La pagination utilise le même mécanisme `page`/`next_page` que le point de terminaison de liste. `limit` vaut 100 par défaut, avec un maximum de 1 000. Une page peut se terminer prématurément lorsque la réponse atteint sa taille limite. Une page contenant moins de `limit` messages ne signifie donc pas que vous avez atteint la fin : continuez à paginer jusqu’à ce que `next_page` vaille `null`.

Chaque message comporte un `role` (`user` ou `assistant`) et un tableau `content` de blocs `text`, `tool_use` et `tool_result`. Les valeurs `created_at` des messages sont des horodatages de validation : des messages consécutifs peuvent partager un même horodatage ou être légèrement inversés ; conservez donc l’ordre renvoyé plutôt que de retrier selon `created_at`. Sur les sessions appartenant à un agent, `sent_by_user_id` enregistre l’utilisateur qui a envoyé un message utilisateur donné lorsqu’il peut être attribué ; il vaut `null` dans le cas contraire, y compris sur tous les messages de l’assistant. Lorsque le contenu d’un message ne peut pas du tout être renvoyé (par exemple, s’il dépasse les limites de taille), le message comporte `content_unavailable` défini à `true`.

Deux paramètres plafonnent le nombre d’octets renvoyés pour chaque bloc d’outil : `tool_use_input_max_bytes` et `tool_result_max_bytes`, tous deux de 10 000 octets par défaut. Transmettez `-1` pour le maximum du serveur (environ 1 Mio par chaîne) ; `0` renvoie [400 Bad Request](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#400-bad-request). Un bloc tronqué par l’un ou l’autre plafond comporte `"truncated": true`, et une entrée `tool_use` tronquée n’est plus du JSON valide ; n’analysez donc les entrées d’outils qu’à partir de blocs non tronqués (ou augmentez le plafond et récupérez-les à nouveau).

Le point de terminaison des messages renvoie [404 Not Found](https://platform.claude.com/docs/fr/manage-claude/compliance-errors#404-not-found) pour les sessions `pending`, les sessions qui n’existent pas ou ont été supprimées, et les sessions des organisations que votre clé ne peut pas lire.

## Conservation et suppression

Les points de terminaison de sessions sont en lecture seule ; les sessions locales et distantes ne peuvent pas être supprimées par leur intermédiaire. Les transcriptions des sessions locales sont conservées 6 ans par défaut, ou pendant la durée de conservation personnalisée des conversations de votre organisation lorsqu’une durée finie est définie, ou 30 jours dans les organisations où la préparation HIPAA est activée, comme décrit dans [Sessions sur les machines des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/compliance-sessions#retrieve-local-sessions).

Les transcriptions des sessions distantes (comme Cowork dans le cloud) n’ont pas de durée de conservation par défaut. Les sessions dans le cloud que Claude démarre à partir d’un chat sont supprimées avec le chat, y compris lorsque la durée de conservation personnalisée des conversations de votre organisation le supprime.

Les transcriptions des sessions Claude Tag n’ont pas non plus de durée de conservation par défaut. Elles sont supprimées lorsque [le canal est retiré de Claude Tag](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#remove-a-channel), lorsque le canal est supprimé dans Slack, lorsque l’espace de travail Slack ou l’Enterprise Grid est déconnecté, et lorsque l’application Slack est désinstallée d’un espace de travail. La suppression de l’installation à l’échelle de l’organisation d’une Enterprise Grid ne les supprime pas. Exportez toute transcription Claude Tag que vous devez conserver avant de retirer un canal ou de déconnecter un espace de travail.

Les points de terminaison de sessions distantes ne renvoient plus une session une fois qu’elle a été supprimée, et sa transcription n’est pas récupérable via la Compliance API. Pour savoir comment la conservation des sessions s’articule avec les autres dispositions de conservation d’Anthropic, consultez [API et conservation des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Récupérer et supprimer des conversations, des fichiers et des projets" href="https://platform.claude.com/docs/fr/manage-claude/compliance-content-data">
    Accédez au contenu des conversations claude.ai, aux pièces jointes et aux projets avec la même Compliance Access Key.
  </Card>

  <Card title="FAQ de la Compliance API" href="https://platform.claude.com/docs/fr/manage-claude/compliance-faq#data-coverage-and-retention">
    Un résumé, champ par champ, du contenu des transcriptions de sessions, ainsi que d’autres questions fréquentes.
  </Card>

  <Card title="Gérer les erreurs de la Compliance API" href="https://platform.claude.com/docs/fr/manage-claude/compliance-errors">
    Les charges utiles d’erreur exactes et la correction pour chacune d’elles.
  </Card>

  <Card title="Référence de l’API" href="https://platform.claude.com/docs/fr/api/compliance/apps">
    Chemins des points de terminaison, paramètres et schémas de réponse de la Compliance API.
  </Card>
</CardGroup>
