Recupera le trascrizioni delle sessioni

Gli endpoint in questa pagina espongono ai revisori della conformità le trascrizioni delle sessioni che i tuoi utenti eseguono nelle app e negli agenti Claude (attualmente: Cowork, Claude Code, Claude Science e Claude for Microsoft 365) dalle tue organizzazioni Claude Enterprise. Ogni sessione è una singola conversazione con Claude; il suo "transcript" (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 per l'"electronic discovery" (individuazione elettronica), o eDiscovery, 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: gli endpoint delle sessioni locali per le sessioni sui computer degli utenti e gli endpoint delle 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 API Admin (sk-ant-admin01-...): le chiamate autenticate con una chiave API Admin restituiscono 403 Forbidden.

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

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 di 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 delle sessioni remote restituiscono solo sessioni di Cowork.
• Sessioni locali nelle organizzazioni con la predisposizione HIPAA abilitata. Non viene acquisito alcun dato delle sessioni locali, quindi gli endpoint delle sessioni locali non restituiscono sessioni per tali organizzazioni.
• Sessioni locali per cui è in vigore la "zero data retention" (conservazione zero dei dati), o ZDR. Queste sessioni sono escluse dai risultati degli elenchi e gli endpoint di recupero e dei messaggi restituiscono 404 per esse.

Anthropic consiglia la Compliance API per recuperare il contenuto delle sessioni. La tabella seguente confronta le sessioni locali e le sessioni remote con le alternative basate su OpenTelemetry disponibili per Cowork e Claude Code, ovvero il logging OpenTelemetry di Cowork e il monitoraggio di Claude Code.

Sessioni sui computer degli utenti (sessioni locali)

Le sessioni locali vengono eseguite sui computer degli utenti mentre hanno effettuato l'accesso con il proprio account Claude Enterprise: attualmente, Cowork in Claude Desktop, Claude Code (nel terminale, in Claude Desktop o in un'estensione IDE), l'app desktop Claude Science e Claude for Microsoft 365 in Excel, PowerPoint, Word e Outlook.

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 delle 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; non viene installato nulla sul dispositivo e non viene raccolto nulla 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à sui file e sulla rete è visibile solo tramite 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 usano le "customer-managed encryption keys" (chiavi di crittografia gestite dal cliente), le trascrizioni delle sessioni locali sono crittografate con la tua chiave gestita dal cliente e restituite normalmente. Finché tale chiave non può essere usata (ad esempio, perché l'hai disabilitata o revocata, o perché non è raggiungibile), l'endpoint dei messaggi restituisce 503 Service Unavailable per le pagine interessate anziché il contenuto della trascrizione. Questi messaggi non vengono mai segnalati come not_captured (consulta Recupera la trascrizione di una sessione locale). L'elenco delle sessioni e il recupero dei metadati delle sessioni non sono interessati.

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. Un terzo filtro temporale, updated_at.gte, delimita in base all'ultima attività anziché alla prima: restituisce le sessioni la cui ultima chiamata di inferenza è avvenuta all'ora indicata o successivamente e si combina con i filtri created_at senza modificare l'ordinamento o la paginazione. Usalo per interrogare periodicamente le sessioni attive dopo un passaggio precedente, come descritto più avanti in questa sezione. 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" \
  --header "anthropic-version: 2023-06-01" \
  --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",
      "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"
}

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 pagina solo in avanti con i token page e next_page (consulta Pagina 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 persiste anche dopo l'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, dà inizio a un nuovo record di sessione. Per Claude Science, l'elenco può includere anche sessioni separate per le attività in background dell'app stessa (ad esempio, l'assegnazione del nome alla conversazione; nelle versioni più recenti dell'app anche i suoi percorsi di revisione e delega), e nelle versioni meno recenti dell'app parte di tali attività in background appare come messaggi aggiuntivi all'interno della trascrizione della conversazione stessa. Una conversazione di Claude Science che prosegue attraverso alcuni aggiornamenti dell'app appare come due sessioni. Questi comportamenti sono previsti. Tratta i valori id come stringhe opache; il formato può cambiare senza preavviso.

Per Claude for Microsoft 365, l'eliminazione di una conversazione nel componente aggiuntivo avviene solo sul client, quindi non si riflette nell'API: le sessioni locali non hanno un campo deleted_at e la sessione rimane elencata finché la conservazione non la rimuove.

Le sessioni locali hanno un updated_at ma nessuno status: una sessione locale non ha uno stato del 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 singolarmente. created_at è il timestamp della chiamata conservata più vecchia della sessione e updated_at quello della sua ultima chiamata, entrambi in UTC. Man mano che le chiamate più vecchie superano il periodo di conservazione, created_at avanza di conseguenza e, una volta che tutte le chiamate di una sessione sono scadute, la sessione non viene più restituita; updated_at segue la chiamata più recente e non è interessato fino ad allora. Poiché created_at può spostarsi tra un'esecuzione e l'altra, deduplica in base a id quando ripercorri l'elenco nel tempo. Per mantenere aggiornate le trascrizioni man mano che le sessioni acquisiscono nuovi messaggi, esegui il "polling" (interrogazione periodica) con il filtro updated_at.gte, sovrapponendo finestre consecutive. Nell'endpoint di elenco updated_at è un limite inferiore: per una sessione ancora attiva al confine di una pagina o di una finestra created_at.lt può momentaneamente essere in ritardo rispetto all'effettiva ultima attività della sessione, e una nuova chiamata diventa interrogabile solo dopo il breve ritardo di elaborazione indicato in precedenza. A causa di questo ritardo, imposta updated_at.gte di ogni esecuzione qualche minuto prima dell'ora di inizio dell'esecuzione precedente, non esattamente all'ora dell'esecuzione precedente. Un limite impostato esattamente all'ora precedente scarta in modo silenzioso e permanente una sessione la cui ultima chiamata era ancora in fase di indicizzazione in quel momento, perché una volta che il limite supera quella chiamata nessuna esecuzione successiva la restituisce. Deduplica le sessioni restituite in base a id, recupera nuovamente le loro trascrizioni e deduplica i messaggi in base a id. Il recupero di una sessione, o dei suoi messaggi, riflette sempre esattamente l'ultima chiamata conservata, quindi un passaggio periodico di riconciliazione su una finestra più vecchia è un'alternativa più accurata all'ampliamento della sovrapposizione.

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

Il contenuto acquisito delle sessioni locali viene conservato per 6 anni dall'acquisizione per impostazione predefinita. Se l'organizzazione che ha eseguito la sessione ha impostato un periodo di conservazione personalizzato finito delle conversazioni in claude.ai > Impostazioni organizzazione > Dati e privacy, si applica invece tale periodo, che sia 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 l'attività più vecchia del periodo corrente dell'organizzazione non appena l'impostazione cambia, mentre ogni messaggio acquisito viene conservato per il periodo in vigore al momento della sua acquisizione, quindi allungare il periodo in seguito non ripristina i 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 non valido 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 di un'altra organizzazione padre), non esiste, per essa è in vigore la conservazione zero dei dati, oppure tutte le sue chiamate hanno superato il periodo di conservazione.

product_surface (stringa o null) identifica il prodotto che ha creato la sessione: cowork (Cowork in Claude Desktop sul computer dell'utente), claude_code (Claude Code), claude_science (Claude Science) oppure uno tra office_agents/excel, office_agents/powerpoint, office_agents/word e office_agents/outlook (Claude for Microsoft 365, per app; solo office_agents quando l'app non è identificata). Nuovi valori compaiono man mano che la copertura si amplia.

Recupera 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 parti testuali 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 tale contenuto, quindi tratta le trascrizioni come sensibili. La trascrizione omette o sostituisce quanto segue:

• I "thinking blocks" (blocchi di pensiero) non sono mai inclusi.
• Il "system prompt" (prompt di sistema) della richiesta non viene mai restituito. Un messaggio marcatore con il testo [system prompt content not shown] lo sostituisce (normalmente una volta per sessione; una sessione senza contenuto acquisito non contiene 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 appare 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 uno strumento, come i risultati della ricerca web o l'output dello strumento di esecuzione del codice, vengono sostituiti da un'unica voce [N non-text item(s) not shown] e il truncated del blocco del risultato dello strumento è true. La chiamata allo strumento corrispondente, con la query di ricerca o il codice nel suo input, viene comunque restituita.
• I metadati delle citazioni sui blocchi text, come le citazioni delle fonti in una risposta che attinge ai risultati della ricerca web, vengono omessi. Il testo stesso viene restituito e il blocco ha truncated impostato su true.

I file di istruzioni del progetto come CLAUDE.md appaiono come normale contenuto con ruolo utente. Il contenuto delle skill appare quando il client lo invia come contenuto del messaggio e non è distinto dal resto del testo dell'utente. Per un riepilogo della copertura, consulta le FAQ sulla Compliance API; per una tabella che confronta le sessioni locali con le sessioni remote e il logging OpenTelemetry, consulta l'introduzione di questa pagina.

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" \
  --header "anthropic-version: 2023-06-01"

{
  "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",
      "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",
      "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 paginato data. Il primo record in questo esempio è il marcatore che sostituisce il prompt di sistema della richiesta; il suo provenance è descritto più avanti in questa sezione. In 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, associa user.id ai dati dell'endpoint di elenco o dell'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'ordine. La paginazione 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 paginare finché next_page non è null. I cursori di pagina sono vincolati 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. Ha anche un model: in un turno dell'assistente acquisito dalla Claude API è il modello che ha servito il turno, ed è null nei messaggi dell'utente e in qualsiasi messaggio dell'assistente il cui provenance sia impostato, perché la cronologia dichiarata dal client e i marcatori sintetici non sono stati prodotti da un modello e il modello che ha servito il turno è sconosciuto per i contenuti non disponibili. 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 appare come segnaposto [<block type> content not shown]. L'id di un messaggio è stabile finché il turno viene conservato. Ogni messaggio ricostruito dalla stessa chiamata di inferenza riporta il timestamp di quella chiamata, quindi messaggi consecutivi condividono spesso lo stesso valore created_at; mantieni 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 i contenuti verificati acquisiti 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 non è disponibile alcun contenuto per il turno. Non dimostra che non sia stato memorizzato alcun record: i contenuti che le policy di gestione dei dati di Anthropic escludono dalla Compliance API vengono segnalati con lo stesso motivo, così come i singoli turni, all'interno di una sessione altrimenti acquisita, che non sono disponibili per tali motivi. Una chiave gestita dal cliente inutilizzabile è l'unica eccezione e restituisce invece 503 Service Unavailable. client_aborted significa che il client ha chiuso la connessione o annullato la richiesta prima del completamento della risposta, quindi la risposta del turno non è stata acquisita; l'eventuale output parziale già inviato in streaming al client non è incluso, e questo motivo si applica solo ai turni con ruolo assistente. cmek_key_revoked è riservato ai contenuti crittografati con la chiave gestita dal cliente della tua organizzazione quando tale chiave non è disponibile (ad esempio, revocata). Attualmente non viene restituito, perché una chiave inutilizzabile produce invece un 503, ma 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 associare 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 cronologia della conversazione a metà sessione (ad esempio, dopo la compattazione del contesto), la trascrizione inserisce un messaggio marcatore in quel punto e prosegue con il nuovo contenuto inviato dal client; quando la tua organizzazione ha un periodo di conservazione finito, la cronologia riscritta stessa viene esclusa (un secondo marcatore lo segnala) e vengono mostrati solo l'ultimo turno dell'utente e ciò che segue.

I messaggi marcatore e quelli dichiarati 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 un 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 al confine di un 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 dati). 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 che raggiunge il limite riporta "truncated": true.

Il contenuto delle trascrizioni rispetta il periodo di conservazione descritto in Sessioni sui computer degli utenti. Quando l'inizio di una sessione ha superato tale periodo, la trascrizione inizia con un unico segnaposto content_unavailable con reason pari a retention_elapsed, seguito dai messaggi conservati. Quando tutte le chiamate di una sessione sono scadute, l'endpoint dei messaggi restituisce 404 Not Found, come avviene per le sessioni in organizzazioni che la tua chiave non può leggere, per le sessioni che non esistono e per le sessioni per cui è in vigore la conservazione zero dei dati. Un ID di sessione non valido 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. Entrambi vengono conteggiati nel "rate limit" (limite di velocità) condiviso della Compliance API e in un secondo budget di richieste specifico per questi endpoint; consulta 429 Too Many Requests.

Per impostazione predefinita, l'endpoint di elenco copre l'intera 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 si applica all'utente proprietario della sessione, quindi le sessioni di proprietà di agenti vengono 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 seguente richiesta 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" \
  --header "anthropic-version: 2023-06-01" \
  --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) in base a created_at, con un massimo di limit risultati per risposta (predefinito 100, massimo 500). L'endpoint usa la paginazione con i token page e next_page (consulta Paginare 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 appartiene a un utente oppure a un agente, mai a entrambi. Per le sessioni di proprietà di un utente, user contiene l'ID e l'indirizzo email del proprietario e agent_id è null. email_address è null quando l'utente non è più membro di un'organizzazione che la tua chiave può leggere. Per le sessioni di proprietà di un agente (ad esempio, le attività pianificate), user è null e agent_id contiene l'ID dell'agente (prefisso cagt_). In questo caso 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 fa parte di un progetto.

status è uno tra pending, active, paused, archived o failed. Una sessione è pending mentre viene predisposta. Una sessione pending non ha ancora una trascrizione, e l'endpoint dei messaggi restituisce 404 finché la predisposizione non è completata. Le sessioni eliminate non vengono mai restituite.

product_surface (stringa o null) identifica il prodotto che ha creato la sessione. Attualmente l'endpoint restituisce solo sessioni con product_surface pari a cowork_remote, cioè le 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, chiamate agli strumenti e relativi risultati. I blocchi di pensiero e le immagini non sono inclusi. Per un riepilogo della copertura, consulta le FAQ sulla Compliance API. L'introduzione di questa pagina contiene una tabella che confronta le sessioni remote con le sessioni locali e con il logging OpenTelemetry di Cowork.

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" \
  --header "anthropic-version: 2023-06-01"

{
  "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 include un envelope session accanto all'array paginato data. Su questo endpoint l'envelope ha sempre user.email_address, started_by_user e claude_project_id impostati su null; ottieni questi valori dall'endpoint di elenco.

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

Ogni messaggio contiene 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 lo stesso timestamp o risultare leggermente invertiti, quindi mantieni l'ordine restituito invece di riordinare in base a created_at. Nelle sessioni di proprietà di un agente, sent_by_user_id registra l'utente che ha inviato un determinato messaggio utente, quando è possibile attribuirlo. Negli altri casi è null, incluso in tutti i messaggi dell'assistente. Quando il contenuto di un messaggio non può essere restituito affatto (ad esempio, perché supera i limiti di dimensione), il messaggio contiene 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 consentito dal server (circa 1 MiB per stringa); 0 restituisce 400 Bad Request. Un blocco troncato da uno dei due limiti contiene "truncated": true. Un input tool_use troncato non è più JSON valido, quindi analizza gli input degli strumenti solo dai blocchi non troncati (oppure aumenta il limite e recupera di nuovo i dati).

L'endpoint dei messaggi restituisce 404 Not Found nei seguenti casi:

• sessioni pending;
• sessioni inesistenti o eliminate;
• 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. Se la tua organizzazione ha impostato un periodo di conservazione personalizzato e finito per le conversazioni, si applica quel periodo, come descritto in Sessioni sui computer degli utenti. Le trascrizioni delle sessioni remote vengono conservate per 6 anni, a meno che un utente non elimini prima la sessione. Dopo l'eliminazione da parte di un utente, gli endpoint delle sessioni remote non restituiscono più la sessione e la sua trascrizione non è recuperabile tramite la Compliance API. Per capire come questi periodi si collocano rispetto agli altri accordi di conservazione di Anthropic, consulta API e conservazione dei dati.

Passaggi successivi