Recuperare le trascrizioni delle sessioni

Gli endpoint di questa pagina espongono ai revisori della conformità le "transcripts" (trascrizioni) delle sessioni che i tuoi utenti eseguono nelle app e negli agenti Claude (oggi, Cowork e Claude Code) delle tue organizzazioni Claude Enterprise. Ogni sessione è una singola conversazione con Claude; la sua trascrizione è la sequenza di prompt dell'utente, risposte dell'assistente e chiamate agli strumenti con i relativi risultati in quella conversazione. Gli endpoint supportano le esportazioni di eDiscovery (electronic discovery, ovvero indagine elettronica) e l'applicazione della "data loss prevention" (prevenzione della perdita di dati), o DLP.

La Compliance API raggruppa le sessioni in due famiglie di endpoint in base a dove vengono eseguite: endpoint per sessioni locali, per le sessioni sulle macchine degli utenti, ed endpoint per sessioni remote, per le sessioni eseguite nel cloud in ambienti gestiti da Anthropic. Entrambe le famiglie sono di sola lettura e nessuna delle due è disponibile per le chiavi Admin API (sk-ant-admin01-...): le chiamate autenticate con una chiave Admin API restituiscono 403 Forbidden.

La tabella seguente associa ciascun prodotto, e il luogo in cui viene eseguito, alla famiglia di endpoint che restituisce le sue sessioni e al valore product_surface che le identifica nelle risposte. I prodotti vengono aggiunti a questa tabella man mano che la copertura si espande.

L'acquisizione delle sessioni locali è legata all'abilitazione della Compliance API per la tua organizzazione e si applica mentre gli utenti hanno effettuato l'accesso con il proprio account Claude Enterprise. Gli endpoint delle sessioni non restituiscono quanto segue:

• Sessioni Claude Code autenticate con una chiave API della Claude Console, o eseguite tramite una piattaforma cloud di terze parti come Amazon Bedrock, Google Cloud o Microsoft Foundry.
• Claude Code sul web. Anch'esso viene eseguito nel cloud in ambienti gestiti da Anthropic, ma non è una sessione remota; gli endpoint per sessioni remote restituiscono solo sessioni Cowork.
• Sessioni locali in organizzazioni con HIPAA readiness abilitata. Nessun dato delle sessioni locali viene acquisito, quindi gli endpoint per sessioni locali non restituiscono sessioni per tali organizzazioni.
• Sessioni locali per le quali è in vigore la zero data retention (ZDR). Queste sessioni sono escluse dai risultati degli elenchi, e gli endpoint di recupero e dei messaggi restituiscono 404 per esse.

La tabella seguente riassume le differenze tra sessioni locali e sessioni remote.



Sessioni sulle macchine degli utenti (sessioni locali)

Le sessioni locali vengono eseguite sulle macchine degli utenti mentre questi hanno effettuato l'accesso con il proprio account Claude Enterprise: oggi, Cowork in Claude Desktop e Claude Code nel terminale, in Claude Desktop o in un'estensione IDE.

La Compliance API espone le sessioni locali tramite tre endpoint: GET /v1/compliance/apps/sessions/local elenca i metadati delle sessioni, GET /v1/compliance/apps/sessions/local/{session_id} recupera i metadati di una sessione e GET /v1/compliance/apps/sessions/local/{session_id}/messages restituisce la trascrizione di una sessione. Tutti e tre richiedono lo scope read:compliance_user_data e vengono conteggiati solo rispetto al "rate limit" (limite di velocità) condiviso della Compliance API; non sono soggetti al secondo budget di richieste che si applica agli endpoint per sessioni remote. Consulta 429 Too Many Requests. Se le sessioni locali non sono disponibili per la tua organizzazione padre, tutti e tre gli endpoint restituiscono 404 con il messaggio Local sessions are not available. (consulta Sessione locale non trovata); mentre gli elenchi delle sessioni o i contenuti acquisiti sono temporaneamente non disponibili, restituiscono 503 (consulta Sessioni locali temporaneamente non disponibili).

Per le sessioni locali, Anthropic registra ogni conversazione lato server man mano che le sue richieste raggiungono la Claude API; nulla viene installato sul dispositivo e nulla viene raccolto oltre alle richieste che il client già invia alla Claude API. Le trascrizioni delle sessioni locali mostrano cosa è stato chiesto a Claude di fare e cosa ha restituito, non cosa è accaduto sul dispositivo. L'attività su file e rete è visibile solo attraverso le chiamate agli strumenti e i risultati degli strumenti nella trascrizione, quindi l'attività che non raggiunge mai l'API (ad esempio, file locali che la sessione non ha mai inviato) non viene acquisita.

Nelle organizzazioni che utilizzano chiavi di crittografia gestite dal cliente, le sessioni locali vengono elencate e sono recuperabili come di consueto, ma il contenuto delle trascrizioni non viene attualmente restituito; ogni messaggio viene restituito con il suo contenuto contrassegnato come non disponibile (consulta Recuperare la trascrizione di una sessione locale per sapere come vengono contrassegnati tali messaggi).

L'endpoint di elenco restituisce i metadati delle sessioni, senza contenuto delle trascrizioni, per ogni organizzazione collegata che la tua chiave può leggere. A differenza dell'elenco delle sessioni remote, non ha filtri per organizzazione o utente: delimita i risultati nel tempo con i parametri created_at.gte e created_at.lt. Entrambi accettano timestamp RFC 3339 con un offset UTC obbligatorio e, quando vengono forniti entrambi, created_at.lt deve essere strettamente successivo a created_at.gte, altrimenti la richiesta restituisce 400 Bad Request. Le nuove sessioni e i nuovi messaggi compaiono nei risultati dopo un breve ritardo di elaborazione, in genere entro pochi minuti; una sessione mancante subito dopo il suo avvio non è necessariamente non acquisita. La richiesta seguente elenca le sessioni create a partire da una determinata data.

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

{
  "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"
    },
    {
      "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"
    }
  ],
  "next_page": "page_AAEfQx7mPdLkq9Rt2VwHbZk"
}

I risultati sono ordinati in ordine cronologico inverso (dal più recente) per created_at, con i pareggi risolti secondo un ordine fisso lato server, e limitati a limit risultati per risposta (predefinito 100, massimo 500). L'endpoint impagina solo in avanti con i token page e next_page (consulta Impaginare i risultati): passa il valore next_page della risposta come parametro di query page nella richiesta successiva e fermati quando next_page è null. La risposta non ha un campo has_more. Completa la scansione di un elenco entro 24 ore dal suo inizio; un cursore di elenco più vecchio viene comunque accettato ma viene rivalutato rispetto al limite di conservazione corrente, quindi le sessioni la cui attività conservata più vecchia sta per uscire dal periodo di conservazione possono essere saltate.

In ogni oggetto sessione, user.id è sempre impostato e sopravvive all'eliminazione dell'account; user.email_address è null quando l'account dell'utente è stato eliminato o l'utente non è più membro di un'organizzazione che la tua chiave può leggere. workspace_id è null quando la sessione non era associata a un workspace. Una sessione locale corrisponde a un ID di sessione del client: avviare una nuova conversazione nel client, o cancellarne il contesto, inizia un nuovo record di sessione. Tratta i valori id come stringhe opache; il formato può cambiare senza preavviso.

Le sessioni locali non hanno status né updated_at: una sessione locale non ha un ciclo di vita lato server e la sua visibilità è invece regolata dalla conservazione. Una sessione locale viene acquisita come la serie di chiamate alla Claude API (chiamate di inferenza) che il client effettua durante la sessione, e la conservazione si applica a ciascuna chiamata acquisita individualmente. created_at è il timestamp della chiamata conservata più vecchia della sessione (UTC). Man mano che le chiamate più vecchie superano il periodo di conservazione, created_at avanza di conseguenza e, una volta che ogni chiamata di una sessione è scaduta, la sessione non viene più restituita. Poiché created_at può spostarsi tra un'esecuzione e l'altra, deduplica su id quando ripercorri l'elenco nel tempo. Il created_at di una sessione non si sposta in avanti man mano che la sessione continua, e non esiste updated_at, quindi una sessione che acquisisce messaggi dopo la tua prima esportazione non ricompare in una finestra created_at successiva. Per mantenere aggiornate le trascrizioni, a ogni esecuzione rielenca una finestra mobile finale lunga almeno quanto le tue sessioni più lunghe e recupera nuovamente le trascrizioni delle sessioni che restituisce, deduplicando i messaggi su id.

L'elenco è costruito a partire dai metadati di attività delle sessioni, quindi può includere sessioni il cui contenuto della trascrizione non è stato acquisito, ad esempio sessioni eseguite prima che l'acquisizione iniziasse per la tua organizzazione (fino a quanto consente il tuo periodo di conservazione); la trascrizione di una tale sessione restituisce ogni messaggio con il suo contenuto contrassegnato come non disponibile (consulta Recuperare la trascrizione di una sessione locale).

Il contenuto acquisito delle sessioni locali viene archiviato per 6 anni dall'acquisizione per impostazione predefinita. Se l'organizzazione che ha eseguito la sessione ha impostato un periodo di conservazione personalizzato finito per le conversazioni in claude.ai > Impostazioni organizzazione > Dati e privacy, si applica invece quel periodo, sia esso più breve o più lungo di quello predefinito; quando l'organizzazione ha configurato più di un periodo di conservazione personalizzato, si applica il più breve. Una modifica a tale impostazione ha effetto in due modi diversi: gli endpoint smettono di restituire attività più vecchie del periodo corrente dell'organizzazione non appena l'impostazione cambia, mentre ogni messaggio acquisito viene archiviato per il periodo in vigore al momento dell'acquisizione, quindi allungare il periodo in seguito non ripristina contenuti già scaduti.

Per recuperare direttamente i metadati di una sessione, passa il suo ID a GET /v1/compliance/apps/sessions/local/{session_id}. La risposta è lo stesso oggetto sessione restituito dall'endpoint di elenco, senza envelope e senza contenuto della trascrizione. Un ID di sessione malformato restituisce 400 Bad Request. Un unico 404 Not Found copre quattro casi che la risposta non distingue: la sessione non si trova in un'organizzazione che la tua chiave può leggere (incluse le sessioni sotto un'altra organizzazione padre), non esiste, per essa è in vigore la zero data retention, oppure ogni sua chiamata ha superato il periodo di conservazione.

product_surface (stringa o null) identifica il prodotto che ha creato la sessione: cowork per le sessioni Cowork in esecuzione sulla macchina dell'utente in Claude Desktop e claude_code per le sessioni Claude Code. Nuovi valori compaiono man mano che la copertura si espande.



Recuperare la trascrizione di una sessione locale

L'endpoint dei messaggi restituisce la trascrizione della sessione, ricostruita dalle chiamate alla Claude API acquisite: prompt dell'utente, testo dell'assistente, chiamate agli strumenti e le porzioni di testo dei risultati degli strumenti, tutti restituiti così come sono stati inviati, a parte il troncamento per dimensione. Nulla maschera URL, credenziali o dati personali in quel contenuto, quindi tratta le trascrizioni come sensibili. La trascrizione omette o sostituisce quanto segue:

• I blocchi di pensiero non sono mai inclusi.
• Il "system prompt" (prompt di sistema) della richiesta non viene mai restituito. Al suo posto compare un messaggio marcatore con il testo [system prompt content not shown] (normalmente una volta per sessione; una sessione senza contenuto acquisito non ha alcun marcatore).
• Le definizioni degli strumenti e la configurazione dei server MCP non fanno parte della trascrizione.
• Immagini, PDF e altri blocchi binari o strutturati non vengono restituiti. Ciascuno compare come un blocco text con il testo [<block type> content not shown] (ad esempio, [image content not shown]) con truncated impostato su true. Gli elementi non testuali all'interno di un risultato di strumento sono sostituiti da una voce [N non-text item(s) not shown], e il truncated del blocco del risultato dello strumento è true.
• I metadati delle citazioni sui blocchi text vengono omessi e il blocco interessato ha truncated impostato su true.

I file di istruzioni del progetto come CLAUDE.md compaiono come normale contenuto con ruolo utente. Il contenuto delle skill compare quando il client lo invia come contenuto del messaggio e non è distinto dall'altro testo dell'utente. Per un riepilogo della copertura e un confronto con il logging OpenTelemetry per Cowork e Claude Code, consulta le FAQ sulla Compliance API.

session_id="clls_01HxKpLmNoPqRsTuVwXyZaBc"

curl --fail-with-body -sS \
  "https://api.anthropic.com/v1/compliance/apps/sessions/local/$session_id/messages" \
  --header "x-api-key: $ANTHROPIC_COMPLIANCE_ACCESS_KEY"

{
  "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"
  },
  "data": [
    {
      "type": "compliance_local_session_message",
      "id": "clsm_01J4KpLmNoPqRsTuVwXyZaBa",
      "role": "user",
      "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",
      "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",
      "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",
      "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",
      "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 risposta incorpora un envelope session accanto all'array data impaginato. Il primo record in questo esempio è il marcatore che sostituisce il prompt di sistema della richiesta; la sua provenance è descritta più avanti in questa sezione. Su questo endpoint user.email_address è sempre null: l'endpoint dei messaggi non risolve gli indirizzi email, quindi un null qui non significa che l'account dell'utente sia stato eliminato. Per attribuire una sessione a un indirizzo email, unisci user.id con l'endpoint di elenco o con l'endpoint di recupero (GET /v1/compliance/apps/sessions/local/{session_id}).

I messaggi vengono restituiti dal più vecchio per impostazione predefinita; passa order=desc per invertire. L'impaginazione usa lo stesso schema page/next_page dell'endpoint di elenco, con un limit predefinito di 100 e un massimo di 1.000. Una pagina può terminare in anticipo quando la risposta raggiunge il suo limite di dimensione, quindi una pagina con meno di limit messaggi non significa che hai raggiunto la fine; continua a impaginare finché next_page non è null. I cursori di pagina sono legati alla sessione e all'ordinamento con cui sono stati emessi, e i cursori di una scansione scadono 24 ore dopo la sua prima pagina: un cursore scaduto restituisce 400 Bad Request indicandoti di ricominciare senza il parametro page, e la scansione riavviata riflette il limite di conservazione corrente. Anche un cursore emesso per una sessione o un order diversi restituisce 400, come cursore non valido.

Ogni messaggio ha un role (user o assistant) e un array content di blocchi text, tool_use e tool_result. Un blocco text contiene text e truncated. Un blocco tool_use contiene id, name, input e truncated, dove input è una stringa codificata in JSON anziché un oggetto. Un blocco tool_result contiene tool_use_id, name, is_error, un array content di voci text e truncated. Le chiamate e i risultati degli strumenti MCP, e la maggior parte delle chiamate e dei risultati degli strumenti server, sono normalizzati in queste stesse forme tool_use e tool_result; qualsiasi altro tipo di blocco compare come segnaposto [<block type> content not shown]. L'id di un messaggio è stabile finché il turno è conservato. Ogni messaggio ricostruito dalla stessa chiamata di inferenza riporta il timestamp di quella chiamata, quindi messaggi consecutivi spesso condividono un valore created_at; preserva l'ordine restituito anziché riordinare per timestamp.

Ogni messaggio ha anche un campo provenance che descrive come è stato acquisito il suo contenuto. provenance è null per il contenuto verificato acquisito dalla Claude API, che è il caso comune. Altrimenti è un oggetto il cui type indica l'eccezione:

• content_unavailable significa che il contenuto non può essere restituito. L'array content è vuoto e provenance.reason ne indica il motivo. not_captured significa che nessun contenuto è disponibile per il turno; non dimostra che nessun record sia stato archiviato, perché il contenuto trattenuto da una policy di accesso lato archiviazione viene segnalato con lo stesso motivo (ad esempio, nelle organizzazioni che utilizzano chiavi di crittografia gestite dal cliente), e singoli turni all'interno di una sessione altrimenti acquisita possono essere non disponibili per altri motivi di gestione dei dati e riportare lo stesso motivo. cmek_key_revoked è riservato al contenuto crittografato con la chiave gestita dal cliente della tua organizzazione quando tale chiave non è disponibile (ad esempio, revocata); attualmente non viene restituito, quindi gestiscilo per compatibilità futura. retention_elapsed significa che il contenuto ha superato il periodo di conservazione. oversize significa che un singolo messaggio ha superato il limite di dimensione per messaggio; il messaggio viene comunque restituito, con un array content vuoto.
• client_asserted contrassegna i messaggi dell'assistente che il client ha fornito come cronologia della conversazione e che non è stato possibile abbinare a una risposta acquisita; la loro paternità non è verificata.
• synthetic_marker contrassegna i record generati dall'endpoint stesso, come il marcatore che sostituisce il prompt di sistema. Quando il client riscrive o compatta la propria cronologia della conversazione a metà sessione (ad esempio, dopo la compattazione del contesto), la trascrizione inserisce un messaggio marcatore in quel punto e continua con il nuovo contenuto inviato dal client; quando la tua organizzazione ha un periodo di conservazione finito, la cronologia riscritta stessa viene trattenuta (un secondo marcatore lo segnala) e vengono mostrati solo l'ultimo turno dell'utente e ciò che segue.

I messaggi marcatore e quelli asseriti dal client iniziano con un blocco text esplicativo tra parentesi quadre contrassegnato con truncated: true, ad esempio [system prompt content not shown]. Tratta questi record come presenti ma non disponibili o non verificati anziché mancanti, e tollera tipi e motivi di provenance non riconosciuti.

Due parametri limitano quanti byte di ciascun blocco di strumento vengono restituiti: tool_use_input_max_bytes e tool_result_max_bytes, entrambi con valore predefinito di 10.000 byte. Passa -1 per il massimo del server (circa 1 MiB per stringa); 0 restituisce 400 Bad Request, e i valori superiori al massimo vengono ridotti a esso. Una stringa tagliata da uno dei due limiti viene tagliata su un confine di carattere e le viene aggiunto un suffisso in-band (ad esempio, …[truncated; pass tool_result_max_bytes=-1 for the server max]), e il suo blocco riporta "truncated": true. Un input di tool_use troncato non è quindi più JSON valido, perciò analizza gli input degli strumenti solo dai blocchi non troncati (oppure aumenta il limite e recupera di nuovo). I blocchi di tipo text sono sempre limitati allo stesso massimo del server di circa 1 MiB; nessun parametro lo aumenta, e anche un blocco text al limite riporta "truncated": true.

Il contenuto della trascrizione rispetta il periodo di conservazione descritto in Sessioni sulle macchine degli utenti. Quando l'inizio di una sessione lo ha superato, la trascrizione inizia con un singolo segnaposto content_unavailable con reason pari a retention_elapsed, seguito dai messaggi conservati. Quando ogni chiamata di una sessione è scaduta, l'endpoint dei messaggi restituisce 404 Not Found, come fa per le sessioni in organizzazioni che la tua chiave non può leggere, le sessioni che non esistono e le sessioni per le quali è in vigore la zero data retention. Un ID di sessione malformato restituisce 400 Bad Request.



Sessioni nel cloud (sessioni remote)

Le sessioni Cowork avviate su claude.ai web o mobile vengono eseguite nel cloud in ambienti gestiti da Anthropic. La Compliance API espone queste sessioni remote tramite due endpoint: GET /v1/compliance/apps/sessions/remote elenca i metadati delle sessioni e GET /v1/compliance/apps/sessions/remote/{session_id}/messages restituisce la trascrizione di una sessione. Entrambi richiedono lo scope read:compliance_user_data ed entrambi vengono conteggiati rispetto al limite di velocità condiviso della Compliance API più un secondo budget di richieste specifico per questi endpoint; consulta 429 Too Many Requests.

L'endpoint di elenco ha per impostazione predefinita un ambito a livello di organizzazione: ometti organization_ids[] per includere ogni organizzazione claude.ai che la tua chiave può leggere, oppure passa fino a 500 valori per restringere l'ambito. Per limitare invece l'elenco a utenti specifici, passa da 1 a 10 valori user_ids[] (ottieni gli ID da Elencare gli utenti dell'organizzazione); il filtro corrisponde all'utente proprietario della sessione, quindi le sessioni di proprietà di agenti sono escluse ogni volta che user_ids[] è impostato. Delimita i risultati nel tempo con i parametri di intervallo created_at (gte, gt, lt, lte, in formato RFC 3339). Non esiste un filtro updated_at. La richiesta seguente elenca le sessioni create a partire da una determinata data.

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

{
  "data": [
    {
      "id": "cse_01WpQrStUvXyZaBcDeFgHjK6",
      "organization_uuid": "91012d09-e48b-438e-a489-1bebfd8fa6f9",
      "user": {
        "id": "user_01XyDMpzjS89pFZXqSFUBDr6",
        "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": null,
      "agent_id": "cagt_01MnPqRsTuVwXyZaBcDeFgH8",
      "started_by_user": {
        "id": "user_01XyDMpzjS89pFZXqSFUBDr6",
        "email_address": "user@example.com"
      },
      "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"
}

I risultati sono ordinati in ordine cronologico inverso (dal più recente) per created_at e limitati a limit risultati per risposta (predefinito 100, massimo 500). L'endpoint impagina con i token page e next_page (consulta Impaginare i risultati): passa il valore next_page della risposta come parametro di query page nella richiesta successiva e fermati quando next_page è null.

Una sessione è di proprietà di un utente o di un agente, mai di entrambi. Per le sessioni di proprietà di un utente, user riporta l'ID e l'indirizzo email del proprietario (email_address è null quando l'utente non è più membro di un'organizzazione che la tua chiave può leggere) e agent_id è null. Per le sessioni di proprietà di un agente (ad esempio, attività pianificate), user è null, agent_id riporta l'ID dell'agente (prefisso cagt_) e started_by_user identifica la persona che ha avviato l'esecuzione, ad esempio avviando un'attività pianificata; nelle sessioni di proprietà di un utente, started_by_user è null.

claude_project_id è l'ID del progetto claude.ai a cui appartiene la sessione (prefisso claude_proj_), oppure null quando la sessione non è in un progetto.

status è uno tra pending, active, paused, archived o failed. Una sessione è pending mentre è in fase di provisioning; una sessione pending non ha ancora una trascrizione e l'endpoint dei messaggi restituisce 404 per essa finché il provisioning non è completato. Le sessioni che sono state eliminate non vengono mai restituite.

product_surface (stringa o null) identifica il prodotto che ha creato la sessione. L'endpoint attualmente restituisce solo sessioni con product_surface pari a cowork_remote: sessioni Cowork avviate su claude.ai web o mobile.



Recuperare la trascrizione di una sessione remota

L'endpoint dei messaggi restituisce la trascrizione della sessione: prompt dell'utente, risposte dell'assistente e chiamate agli strumenti con i relativi risultati. I blocchi di pensiero e le immagini non sono inclusi. Per un riepilogo della copertura e un confronto con il logging OpenTelemetry di Cowork, consulta le FAQ sulla Compliance API.

session_id="cse_01WpQrStUvXyZaBcDeFgHjK6"

curl --fail-with-body -sS \
  "https://api.anthropic.com/v1/compliance/apps/sessions/remote/$session_id/messages" \
  --header "x-api-key: $ANTHROPIC_COMPLIANCE_ACCESS_KEY"

{
  "session": {
    "id": "cse_01WpQrStUvXyZaBcDeFgHjK6",
    "organization_uuid": "91012d09-e48b-438e-a489-1bebfd8fa6f9",
    "user": {
      "id": "user_01XyDMpzjS89pFZXqSFUBDr6",
      "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 risposta incorpora un envelope session accanto all'array data impaginato. Su questo endpoint l'envelope ha sempre user.email_address, started_by_user e claude_project_id impostati su null; ottieni invece quei valori dall'endpoint di elenco.

I messaggi vengono restituiti dal più vecchio per impostazione predefinita; passa order=desc per invertire. L'impaginazione usa lo stesso schema page/next_page dell'endpoint di elenco, con un limit predefinito di 100 e un massimo di 1.000. Una pagina può terminare in anticipo quando la risposta raggiunge il suo limite di dimensione, quindi una pagina con meno di limit messaggi non significa che hai raggiunto la fine; continua a impaginare finché next_page non è null.

Ogni messaggio ha un role (user o assistant) e un array content di blocchi text, tool_use e tool_result. I valori created_at dei messaggi sono timestamp di commit: messaggi consecutivi possono condividere un timestamp o invertirsi leggermente, quindi preserva l'ordine restituito anziché riordinare per created_at. Nelle sessioni di proprietà di un agente, sent_by_user_id registra l'utente che ha inviato un determinato messaggio utente quando è attribuibile; altrimenti è null, incluso in tutti i messaggi dell'assistente. Quando il contenuto di un messaggio non può essere restituito affatto (ad esempio, supera i limiti di dimensione), il messaggio riporta content_unavailable impostato su true.

Due parametri limitano quanti byte di ciascun blocco di strumento vengono restituiti: tool_use_input_max_bytes e tool_result_max_bytes, entrambi con valore predefinito di 10.000 byte. Passa -1 per il massimo del server (circa 1 MiB per stringa); 0 restituisce 400 Bad Request. Un blocco tagliato da uno dei due limiti riporta "truncated": true, e un input tool_use troncato non è più JSON valido, perciò analizza gli input degli strumenti solo dai blocchi non troncati (oppure aumenta il limite e recupera di nuovo).

L'endpoint dei messaggi restituisce 404 Not Found per le sessioni pending, le sessioni che non esistono o sono state eliminate e le sessioni in organizzazioni che la tua chiave non può leggere.



Conservazione ed eliminazione

Gli endpoint delle sessioni sono di sola lettura; le sessioni locali e remote non possono essere eliminate tramite la Compliance API. Le trascrizioni delle sessioni locali vengono conservate per 6 anni per impostazione predefinita, oppure per il periodo di conservazione personalizzato delle conversazioni della tua organizzazione quando ne è impostato uno finito, come descritto in Sessioni sulle macchine degli utenti. Le trascrizioni delle sessioni remote vengono conservate per 6 anni. Per sapere come questi periodi si collocano rispetto agli altri accordi di conservazione di Anthropic, consulta API e conservazione dei dati.



Passaggi successivi