Claude Platform Docs

Beta

Models
type AnthropicBeta string
One of the following:
type BetaAPIError struct { Type: "api_error"; Message }
Type APIError
defaultapi_error
Message string
defaultInternal server error
type BetaAuthenticationError struct { Type: "authentication_error"; Message }
Type AuthenticationError
defaultauthentication_error
Message string
defaultAuthentication error
type BetaBillingError struct { Type: "billing_error"; Message }
Type BillingError
defaultbilling_error
Message string
defaultBilling error
type BetaCurrency string
type BetaErrorUnion interface{…}
One of the following:
type BetaErrorResponse struct { Type: "error"; Error; RequestID }
Type Error
defaulterror
Error BetaErrorUnion
One of the following:
RequestID string
type BetaGatewayTimeoutError struct { Type: "timeout_error"; Message }
Type TimeoutError
defaulttimeout_error
Message string
defaultRequest timeout
type BetaInvalidRequestError struct { Type: "invalid_request_error"; Message }
Type InvalidRequestError
defaultinvalid_request_error
Message string
defaultInvalid request
type BetaMonetaryAmount struct { Amount; Currency }

A monetary amount in a specific currency.

Amount string

Amount in minor units of the currency, as an integer decimal string with no leading zeros: "2500" is $25.00 and "50" is fifty cents. A string rather than a number so no float rounding is ever applied.

Currency BetaCurrency

Uppercase ISO-4217 currency code. USD is the only currency currently supported; the accepted set is closed and grows only when a new currency is priced.

type BetaNotFoundError struct { Type: "not_found_error"; Message }
Type NotFoundError
defaultnot_found_error
Message string
defaultNot found
type BetaOverloadedError struct { Type: "overloaded_error"; Message }
Type OverloadedError
defaultoverloaded_error
Message string
defaultOverloaded
type BetaPermissionError struct { Type: "permission_error"; Message }
Type PermissionError
defaultpermission_error
Message string
defaultPermission denied
type BetaRateLimitError struct { Type: "rate_limit_error"; Message }
Type RateLimitError
defaultrate_limit_error
Message string
defaultRate limited

BetaModelli

Elenca i modelli
client.Beta.Models.List(ctx, params) (*Page[BetaModelInfo], error)
GET/v1/models

Elenca i modelli disponibili.

Ottieni un modello
client.Beta.Models.Get(ctx, modelID, query) (*BetaModelInfo, error)
GET/v1/models/{model_id}

Ottieni un modello specifico.

BetaMessaggi

Crea un messaggio
client.Beta.Messages.New(ctx, params) (*BetaMessage, error)
POST/v1/messages

Invia un elenco strutturato di messaggi di input con contenuto testuale e/o immagini, e il modello genererà il messaggio successivo nella conversazione.

Conta i token in un messaggio
client.Beta.Messages.CountTokens(ctx, params) (*BetaMessageTokensCount, error)
POST/v1/messages/count_tokens

Conta il numero di token in un messaggio.

BetaMessaggiBatch

Crea un batch di messaggi
client.Beta.Messages.Batches.New(ctx, params) (*BetaMessageBatch, error)
POST/v1/messages/batches

Invia un batch di richieste di creazione di messaggi.

Recupera un batch di messaggi
client.Beta.Messages.Batches.Get(ctx, messageBatchID, query) (*BetaMessageBatch, error)
GET/v1/messages/batches/{message_batch_id}

Questo endpoint è idempotente e può essere utilizzato per eseguire il polling del completamento di un batch di messaggi. Per accedere ai risultati di un batch di messaggi, effettua una richiesta all'URL indicato nel campo results_url della risposta.

Elenca i batch di messaggi
client.Beta.Messages.Batches.List(ctx, params) (*Page[BetaMessageBatch], error)
GET/v1/messages/batches

Elenca tutti i batch di messaggi all'interno di un Workspace. I batch creati più di recente vengono restituiti per primi.

Annulla un batch di messaggi
client.Beta.Messages.Batches.Cancel(ctx, messageBatchID, body) (*BetaMessageBatch, error)
POST/v1/messages/batches/{message_batch_id}/cancel

I batch possono essere annullati in qualsiasi momento prima del termine dell'elaborazione. Una volta avviato l'annullamento, il batch entra nello stato canceling, durante il quale il sistema può completare eventuali richieste in corso non interrompibili prima di finalizzare l'annullamento.

Elimina un batch di messaggi
client.Beta.Messages.Batches.Delete(ctx, messageBatchID, body) (*BetaDeletedMessageBatch, error)
DELETE/v1/messages/batches/{message_batch_id}
Recupera i risultati di un batch di messaggi
client.Beta.Messages.Batches.ResultsStreaming(ctx, messageBatchID, query) *jsonl.Stream[BetaMessageBatchIndividualResponse]
GET/v1/messages/batches/{message_batch_id}/results

Trasmette in streaming i risultati di un batch di messaggi come file .jsonl.

BetaAgenti

Crea agente
client.Beta.Agents.New(ctx, params) (*BetaManagedAgentsAgent, error)
POST/v1/agents
Elenca gli agenti
client.Beta.Agents.List(ctx, params) (*PageCursor[BetaManagedAgentsAgent], error)
GET/v1/agents
Ottieni agente
client.Beta.Agents.Get(ctx, agentID, params) (*BetaManagedAgentsAgent, error)
GET/v1/agents/{agent_id}
Aggiorna agente
client.Beta.Agents.Update(ctx, agentID, params) (*BetaManagedAgentsAgent, error)
POST/v1/agents/{agent_id}
Archivia agente
client.Beta.Agents.Archive(ctx, agentID, body) (*BetaManagedAgentsAgent, error)
POST/v1/agents/{agent_id}/archive

BetaAgentiVersioni

Elenca le versioni dell'agente
client.Beta.Agents.Versions.List(ctx, agentID, params) (*PageCursor[BetaManagedAgentsAgent], error)
GET/v1/agents/{agent_id}/versions

BetaAmbienti

Crea ambiente
client.Beta.Environments.New(ctx, params) (*BetaEnvironment, error)
POST/v1/environments

Crea un nuovo ambiente con la configurazione specificata.

Elenca gli ambienti
client.Beta.Environments.List(ctx, params) (*PageCursor[BetaEnvironment], error)
GET/v1/environments

Elenca gli ambienti con supporto per la paginazione.

Ottieni ambiente
client.Beta.Environments.Get(ctx, environmentID, query) (*BetaEnvironment, error)
GET/v1/environments/{environment_id}

Recupera un ambiente specifico tramite ID.

Aggiorna ambiente
client.Beta.Environments.Update(ctx, environmentID, params) (*BetaEnvironment, error)
POST/v1/environments/{environment_id}

Aggiorna la configurazione di un ambiente esistente.

Elimina ambiente
client.Beta.Environments.Delete(ctx, environmentID, body) (*BetaEnvironmentDeleteResponse, error)
DELETE/v1/environments/{environment_id}

Elimina un ambiente tramite ID. Restituisce una conferma dell'eliminazione.

Archivia ambiente
client.Beta.Environments.Archive(ctx, environmentID, body) (*BetaEnvironment, error)
POST/v1/environments/{environment_id}/archive

Archivia un ambiente tramite ID. Gli ambienti archiviati non possono essere utilizzati per creare nuove sessioni.

BetaAmbientiLavoro

Ottieni elemento di lavoro
client.Beta.Environments.Work.Get(ctx, workID, params) (*BetaSelfHostedWork, error)
GET/v1/environments/{environment_id}/work/{work_id}

Nota: questi endpoint vengono chiamati automaticamente dal worker di ambiente predefinito fornito negli SDK e nella CLI, per orchestrare le sessioni con ambienti sandbox self-hosted. Sono inclusi qui come riferimento; non è necessario invocarli direttamente.

Esegui polling del lavoro
client.Beta.Environments.Work.Poll(ctx, environmentID, params) (*BetaSelfHostedWork, error)
GET/v1/environments/{environment_id}/work/poll

Nota: questi endpoint vengono chiamati automaticamente dal worker di ambiente predefinito fornito negli SDK e nella CLI, per orchestrare le sessioni con ambienti sandbox self-hosted. Sono inclusi qui come riferimento; non è necessario invocarli direttamente.

Conferma ricezione del lavoro
client.Beta.Environments.Work.Ack(ctx, workID, params) (*BetaSelfHostedWork, error)
POST/v1/environments/{environment_id}/work/{work_id}/ack

Nota: questi endpoint vengono chiamati automaticamente dal worker di ambiente predefinito fornito negli SDK e nella CLI, per orchestrare le sessioni con ambienti sandbox self-hosted. Sono inclusi qui come riferimento; non è necessario invocarli direttamente.

Registra heartbeat
client.Beta.Environments.Work.Heartbeat(ctx, workID, params) (*BetaSelfHostedWorkHeartbeatResponse, error)
POST/v1/environments/{environment_id}/work/{work_id}/heartbeat

Nota: questi endpoint vengono chiamati automaticamente dal worker di ambiente predefinito fornito negli SDK e nella CLI, per orchestrare le sessioni con ambienti sandbox self-hosted. Sono inclusi qui come riferimento; non è necessario invocarli direttamente.

Arresta lavoro
client.Beta.Environments.Work.Stop(ctx, workID, params) (*BetaSelfHostedWork, error)
POST/v1/environments/{environment_id}/work/{work_id}/stop

Nota: questi endpoint vengono chiamati automaticamente dal worker di ambiente predefinito fornito negli SDK e nella CLI, per orchestrare le sessioni con ambienti sandbox self-hosted. Sono inclusi qui come riferimento; non è necessario invocarli direttamente.

Elenca gli elementi di lavoro
client.Beta.Environments.Work.List(ctx, environmentID, params) (*PageCursor[BetaSelfHostedWork], error)
GET/v1/environments/{environment_id}/work

Nota: questi endpoint vengono chiamati automaticamente dal worker di ambiente predefinito fornito negli SDK e nella CLI, per orchestrare le sessioni con ambienti sandbox self-hosted. Sono inclusi qui come riferimento; non è necessario invocarli direttamente.

Aggiorna elemento di lavoro
client.Beta.Environments.Work.Update(ctx, workID, params) (*BetaSelfHostedWork, error)
POST/v1/environments/{environment_id}/work/{work_id}

Nota: questi endpoint vengono chiamati automaticamente dal worker di ambiente predefinito fornito negli SDK e nella CLI, per orchestrare le sessioni con ambienti sandbox self-hosted. Sono inclusi qui come riferimento; non è necessario invocarli direttamente.

Ottieni statistiche della coda
client.Beta.Environments.Work.Stats(ctx, environmentID, query) (*BetaSelfHostedWorkQueueStats, error)
GET/v1/environments/{environment_id}/work/stats

Ottieni statistiche sulla coda di lavoro per un ambiente.

BetaSessioni

Crea sessione
client.Beta.Sessions.New(ctx, params) (*BetaManagedAgentsSession, error)
POST/v1/sessions
Elenca le sessioni
client.Beta.Sessions.List(ctx, params) (*BidirectionalPageCursor[BetaManagedAgentsSession], error)
GET/v1/sessions
Ottieni sessione
client.Beta.Sessions.Get(ctx, sessionID, query) (*BetaManagedAgentsSession, error)
GET/v1/sessions/{session_id}
Aggiorna sessione
client.Beta.Sessions.Update(ctx, sessionID, params) (*BetaManagedAgentsSession, error)
POST/v1/sessions/{session_id}
Elimina sessione
client.Beta.Sessions.Delete(ctx, sessionID, body) (*BetaManagedAgentsDeletedSession, error)
DELETE/v1/sessions/{session_id}
Archivia sessione
client.Beta.Sessions.Archive(ctx, sessionID, body) (*BetaManagedAgentsSession, error)
POST/v1/sessions/{session_id}/archive

BetaSessioniEventi

Elenca gli eventi
client.Beta.Sessions.Events.List(ctx, sessionID, params) (*PageCursor[BetaManagedAgentsSessionEventUnion], error)
GET/v1/sessions/{session_id}/events
Invia eventi
client.Beta.Sessions.Events.Send(ctx, sessionID, params) (*BetaManagedAgentsSendSessionEvents, error)
POST/v1/sessions/{session_id}/events
Trasmetti eventi in streaming
client.Beta.Sessions.Events.StreamEvents(ctx, sessionID, params) *ssestream.Stream[BetaManagedAgentsStreamSessionEventsUnion]
GET/v1/sessions/{session_id}/events/stream

BetaSessioniRisorse

Aggiungi risorsa di sessione
client.Beta.Sessions.Resources.Add(ctx, sessionID, params) (*BetaManagedAgentsFileResource, error)
POST/v1/sessions/{session_id}/resources
Elenca le risorse di sessione
client.Beta.Sessions.Resources.List(ctx, sessionID, params) (*PageCursor[BetaManagedAgentsSessionResourceUnion], error)
GET/v1/sessions/{session_id}/resources
Ottieni risorsa di sessione
client.Beta.Sessions.Resources.Get(ctx, resourceID, params) (*BetaSessionResourceGetResponseUnion, error)
GET/v1/sessions/{session_id}/resources/{resource_id}
Aggiorna risorsa di sessione
client.Beta.Sessions.Resources.Update(ctx, resourceID, params) (*BetaSessionResourceUpdateResponseUnion, error)
POST/v1/sessions/{session_id}/resources/{resource_id}
Elimina risorsa di sessione
client.Beta.Sessions.Resources.Delete(ctx, resourceID, params) (*BetaManagedAgentsDeleteSessionResource, error)
DELETE/v1/sessions/{session_id}/resources/{resource_id}

BetaSessioniThread

Elenca i thread di sessione
client.Beta.Sessions.Threads.List(ctx, sessionID, params) (*PageCursor[BetaManagedAgentsSessionThread], error)
GET/v1/sessions/{session_id}/threads
Ottieni thread di sessione
client.Beta.Sessions.Threads.Get(ctx, threadID, params) (*BetaManagedAgentsSessionThread, error)
GET/v1/sessions/{session_id}/threads/{thread_id}
Archivia thread di sessione
client.Beta.Sessions.Threads.Archive(ctx, threadID, params) (*BetaManagedAgentsSessionThread, error)
POST/v1/sessions/{session_id}/threads/{thread_id}/archive

BetaSessioniThreadEventi

Elenca gli eventi del thread di sessione
client.Beta.Sessions.Threads.Events.List(ctx, threadID, params) (*PageCursor[BetaManagedAgentsSessionEventUnion], error)
GET/v1/sessions/{session_id}/threads/{thread_id}/events
Trasmetti in streaming gli eventi del thread di sessione
client.Beta.Sessions.Threads.Events.StreamEvents(ctx, threadID, params) *ssestream.Stream[BetaManagedAgentsStreamSessionThreadEventsUnion]
GET/v1/sessions/{session_id}/threads/{thread_id}/stream

BetaDeployment

Crea deployment
client.Beta.Deployments.New(ctx, params) (*BetaManagedAgentsDeployment, error)
POST/v1/deployments
Elenca i deployment
client.Beta.Deployments.List(ctx, params) (*PageCursor[BetaManagedAgentsDeployment], error)
GET/v1/deployments
Ottieni deployment
client.Beta.Deployments.Get(ctx, deploymentID, query) (*BetaManagedAgentsDeployment, error)
GET/v1/deployments/{deployment_id}
Aggiorna deployment
client.Beta.Deployments.Update(ctx, deploymentID, params) (*BetaManagedAgentsDeployment, error)
POST/v1/deployments/{deployment_id}
Archivia deployment
client.Beta.Deployments.Archive(ctx, deploymentID, body) (*BetaManagedAgentsDeployment, error)
POST/v1/deployments/{deployment_id}/archive
Esegui deployment ora
client.Beta.Deployments.Run(ctx, deploymentID, body) (*BetaManagedAgentsDeploymentRun, error)
POST/v1/deployments/{deployment_id}/run
Sospendi deployment
client.Beta.Deployments.Pause(ctx, deploymentID, body) (*BetaManagedAgentsDeployment, error)
POST/v1/deployments/{deployment_id}/pause
Riprendi deployment
client.Beta.Deployments.Unpause(ctx, deploymentID, body) (*BetaManagedAgentsDeployment, error)
POST/v1/deployments/{deployment_id}/unpause

BetaEsecuzioni del deployment

Elenca esecuzioni del deployment
client.Beta.DeploymentRuns.List(ctx, params) (*PageCursor[BetaManagedAgentsDeploymentRun], error)
GET/v1/deployment_runs
Ottieni esecuzione del deployment
client.Beta.DeploymentRuns.Get(ctx, deploymentRunID, query) (*BetaManagedAgentsDeploymentRun, error)
GET/v1/deployment_runs/{deployment_run_id}

BetaVault

Crea vault
client.Beta.Vaults.New(ctx, params) (*BetaManagedAgentsVault, error)
POST/v1/vaults
Elenca vault
client.Beta.Vaults.List(ctx, params) (*PageCursor[BetaManagedAgentsVault], error)
GET/v1/vaults
Ottieni vault
client.Beta.Vaults.Get(ctx, vaultID, query) (*BetaManagedAgentsVault, error)
GET/v1/vaults/{vault_id}
Aggiorna vault
client.Beta.Vaults.Update(ctx, vaultID, params) (*BetaManagedAgentsVault, error)
POST/v1/vaults/{vault_id}
Elimina vault
client.Beta.Vaults.Delete(ctx, vaultID, body) (*BetaManagedAgentsDeletedVault, error)
DELETE/v1/vaults/{vault_id}
Archivia vault
client.Beta.Vaults.Archive(ctx, vaultID, body) (*BetaManagedAgentsVault, error)
POST/v1/vaults/{vault_id}/archive

BetaVaultCredenziali

Crea credenziale
client.Beta.Vaults.Credentials.New(ctx, vaultID, params) (*BetaManagedAgentsCredential, error)
POST/v1/vaults/{vault_id}/credentials
Elenca credenziali
client.Beta.Vaults.Credentials.List(ctx, vaultID, params) (*PageCursor[BetaManagedAgentsCredential], error)
GET/v1/vaults/{vault_id}/credentials
Ottieni credenziale
client.Beta.Vaults.Credentials.Get(ctx, credentialID, params) (*BetaManagedAgentsCredential, error)
GET/v1/vaults/{vault_id}/credentials/{credential_id}
Aggiorna credenziale
client.Beta.Vaults.Credentials.Update(ctx, credentialID, params) (*BetaManagedAgentsCredential, error)
POST/v1/vaults/{vault_id}/credentials/{credential_id}
Elimina credenziale
client.Beta.Vaults.Credentials.Delete(ctx, credentialID, params) (*BetaManagedAgentsDeletedCredential, error)
DELETE/v1/vaults/{vault_id}/credentials/{credential_id}
Archivia credenziale
client.Beta.Vaults.Credentials.Archive(ctx, credentialID, params) (*BetaManagedAgentsCredential, error)
POST/v1/vaults/{vault_id}/credentials/{credential_id}/archive
Convalida credenziale
client.Beta.Vaults.Credentials.MCPOAuthValidate(ctx, credentialID, params) (*BetaManagedAgentsCredentialValidation, error)
POST/v1/vaults/{vault_id}/credentials/{credential_id}/mcp_oauth_validate

BetaArchivi di memoria

Crea un archivio di memoria
client.Beta.MemoryStores.New(ctx, params) (*BetaManagedAgentsMemoryStore, error)
POST/v1/memory_stores
Elenca archivi di memoria
client.Beta.MemoryStores.List(ctx, params) (*PageCursor[BetaManagedAgentsMemoryStore], error)
GET/v1/memory_stores
Recupera un archivio di memoria
client.Beta.MemoryStores.Get(ctx, memoryStoreID, query) (*BetaManagedAgentsMemoryStore, error)
GET/v1/memory_stores/{memory_store_id}
Aggiorna un archivio di memoria
client.Beta.MemoryStores.Update(ctx, memoryStoreID, params) (*BetaManagedAgentsMemoryStore, error)
POST/v1/memory_stores/{memory_store_id}
Elimina un archivio di memoria
client.Beta.MemoryStores.Delete(ctx, memoryStoreID, body) (*BetaManagedAgentsDeletedMemoryStore, error)
DELETE/v1/memory_stores/{memory_store_id}
Archivia un archivio di memoria
client.Beta.MemoryStores.Archive(ctx, memoryStoreID, body) (*BetaManagedAgentsMemoryStore, error)
POST/v1/memory_stores/{memory_store_id}/archive

BetaArchivi di memoriaMemorie

Crea una memoria
client.Beta.MemoryStores.Memories.New(ctx, memoryStoreID, params) (*BetaManagedAgentsMemory, error)
POST/v1/memory_stores/{memory_store_id}/memories
Elenca memorie
client.Beta.MemoryStores.Memories.List(ctx, memoryStoreID, params) (*PageCursor[BetaManagedAgentsMemoryListItemUnion], error)
GET/v1/memory_stores/{memory_store_id}/memories
Recupera una memoria
client.Beta.MemoryStores.Memories.Get(ctx, memoryID, params) (*BetaManagedAgentsMemory, error)
GET/v1/memory_stores/{memory_store_id}/memories/{memory_id}
Aggiorna una memoria
client.Beta.MemoryStores.Memories.Update(ctx, memoryID, params) (*BetaManagedAgentsMemory, error)
POST/v1/memory_stores/{memory_store_id}/memories/{memory_id}
Elimina una memoria
client.Beta.MemoryStores.Memories.Delete(ctx, memoryID, params) (*BetaManagedAgentsDeletedMemory, error)
DELETE/v1/memory_stores/{memory_store_id}/memories/{memory_id}

BetaArchivi di memoriaVersioni della memoria

Elenca versioni della memoria
client.Beta.MemoryStores.MemoryVersions.List(ctx, memoryStoreID, params) (*PageCursor[BetaManagedAgentsMemoryVersion], error)
GET/v1/memory_stores/{memory_store_id}/memory_versions
Recupera una versione della memoria
client.Beta.MemoryStores.MemoryVersions.Get(ctx, memoryVersionID, params) (*BetaManagedAgentsMemoryVersion, error)
GET/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}
Oscura una versione della memoria
client.Beta.MemoryStores.MemoryVersions.Redact(ctx, memoryVersionID, params) (*BetaManagedAgentsMemoryVersion, error)
POST/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}/redact

BetaFile

Carica file
client.Beta.Files.Upload(ctx, params) (*BetaFileMetadata, error)
POST/v1/files
Elenca i file
client.Beta.Files.List(ctx, params) (*PageCursor[BetaFileMetadata], error)
GET/v1/files
Scarica file
client.Beta.Files.Download(ctx, fileID, query) (*Response, error)
GET/v1/files/{file_id}/content
Ottieni metadati del file
client.Beta.Files.GetMetadata(ctx, fileID, query) (*BetaFileMetadata, error)
GET/v1/files/{file_id}
Elimina file
client.Beta.Files.Delete(ctx, fileID, body) (*BetaDeletedFile, error)
DELETE/v1/files/{file_id}

BetaSkill

Crea skill
client.Beta.Skills.New(ctx, params) (*BetaSkill, error)
POST/v1/skills
Elenca le skill
client.Beta.Skills.List(ctx, params) (*PageCursor[BetaSkill], error)
GET/v1/skills
Ottieni skill
client.Beta.Skills.Get(ctx, skillID, query) (*BetaSkill, error)
GET/v1/skills/{skill_id}
Elimina skill
client.Beta.Skills.Delete(ctx, skillID, body) (*BetaDeletedSkill, error)
DELETE/v1/skills/{skill_id}

BetaSkillVersioni

Crea versione della skill
client.Beta.Skills.Versions.New(ctx, skillID, params) (*BetaSkillVersion, error)
POST/v1/skills/{skill_id}/versions
Elenca le versioni della skill
client.Beta.Skills.Versions.List(ctx, skillID, params) (*PageCursor[BetaSkillVersion], error)
GET/v1/skills/{skill_id}/versions
Scarica contenuto versione skill
client.Beta.Skills.Versions.Download(ctx, version, params) (*Response, error)
GET/v1/skills/{skill_id}/versions/{version}/content

Scarica il contenuto di una versione della skill come archivio zip.

Ottieni versione della skill
client.Beta.Skills.Versions.Get(ctx, version, params) (*BetaSkillVersion, error)
GET/v1/skills/{skill_id}/versions/{version}
Elimina versione della skill
client.Beta.Skills.Versions.Delete(ctx, version, params) (*BetaDeletedSkillVersion, error)
DELETE/v1/skills/{skill_id}/versions/{version}

BetaProfili utente

Crea profilo utente
client.Beta.UserProfiles.New(ctx, params) (*BetaUserProfile, error)
POST/v1/user_profiles
Elenca profili utente
client.Beta.UserProfiles.List(ctx, params) (*PageCursor[BetaUserProfile], error)
GET/v1/user_profiles
Ottieni profilo utente
client.Beta.UserProfiles.Get(ctx, userProfileID, query) (*BetaUserProfile, error)
GET/v1/user_profiles/{user_profile_id}
Aggiorna profilo utente
client.Beta.UserProfiles.Update(ctx, userProfileID, params) (*BetaUserProfile, error)
POST/v1/user_profiles/{user_profile_id}
Crea URL di registrazione
client.Beta.UserProfiles.NewEnrollmentURL(ctx, userProfileID, body) (*BetaUserProfileEnrollmentURL, error)
POST/v1/user_profiles/{user_profile_id}/enrollment_url

BetaDream

Crea un Dream
client.Beta.Dreams.New(ctx, params) (*BetaDream, error)
POST/v1/dreams

Avvia un job asincrono che usa le sessioni passate per produrre una versione riorganizzata di un archivio di memoria e restituisce il dream da interrogare per ottenere il risultato.

Elenca Dream
client.Beta.Dreams.List(ctx, params) (*PageCursor[BetaDream], error)
GET/v1/dreams

Elenca i dream nel workspace, dal più recente.

Ottieni un Dream
client.Beta.Dreams.Get(ctx, dreamID, query) (*BetaDream, error)
GET/v1/dreams/{dream_id}

Ottieni un dream tramite ID per verificarne lo stato, l'archivio di memoria di output e l'utilizzo dei token.

Annulla un Dream
client.Beta.Dreams.Cancel(ctx, dreamID, body) (*BetaDream, error)
POST/v1/dreams/{dream_id}/cancel

Interrompi un dream pending o running.

Archivia un Dream
client.Beta.Dreams.Archive(ctx, dreamID, body) (*BetaDream, error)
POST/v1/dreams/{dream_id}/archive

Nascondi un dream completed, failed o canceled dall'elenco predefinito dei dream.

BetaTunnel

Crea tunnel
client.Beta.Tunnels.New(ctx, params) (*BetaTunnel, error)
POST/v1/tunnels

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Ottieni tunnel
client.Beta.Tunnels.Get(ctx, tunnelID, query) (*BetaTunnel, error)
GET/v1/tunnels/{tunnel_id}

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Elenca tunnel
client.Beta.Tunnels.List(ctx, params) (*PageCursor[BetaTunnel], error)
GET/v1/tunnels

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Archivia tunnel
client.Beta.Tunnels.Archive(ctx, tunnelID, body) (*BetaTunnel, error)
POST/v1/tunnels/{tunnel_id}/archive

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Rivela token del tunnel
client.Beta.Tunnels.RevealToken(ctx, tunnelID, body) (*BetaTunnelToken, error)
POST/v1/tunnels/{tunnel_id}/reveal_token

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Ruota token del tunnel
client.Beta.Tunnels.RotateToken(ctx, tunnelID, params) (*BetaTunnelToken, error)
POST/v1/tunnels/{tunnel_id}/rotate_token

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

BetaTunnelCertificati

Crea certificato del tunnel
client.Beta.Tunnels.Certificates.New(ctx, tunnelID, params) (*BetaTunnelCertificate, error)
POST/v1/tunnels/{tunnel_id}/certificates

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Ottieni certificato del tunnel
client.Beta.Tunnels.Certificates.Get(ctx, certificateID, params) (*BetaTunnelCertificate, error)
GET/v1/tunnels/{tunnel_id}/certificates/{certificate_id}

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Elenca certificati del tunnel
client.Beta.Tunnels.Certificates.List(ctx, tunnelID, params) (*PageCursor[BetaTunnelCertificate], error)
GET/v1/tunnels/{tunnel_id}/certificates

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

Archivia certificato del tunnel
client.Beta.Tunnels.Certificates.Archive(ctx, certificateID, params) (*BetaTunnelCertificate, error)
POST/v1/tunnels/{tunnel_id}/certificates/{certificate_id}/archive

L'API Tunnels è in research preview (anteprima di ricerca). Richiede l'header anthropic-beta: mcp-tunnels-2026-06-22 e può cambiare senza un periodo di deprecazione. Sostituisce gli endpoint dell'Admin API in /v1/organizations/tunnels, che rimangono disponibili durante una finestra di migrazione.

BetaOrganizzazione

Ottieni l'organizzazione corrente
client.Beta.Organization.Get(ctx) (*BetaOrganization, error)
GET/v1/organizations/me

Recupera le informazioni sull'organizzazione associata alla chiave API autenticata.

BetaOrganizzazioneChiavi API

Elenca le chiavi API
client.Beta.Organization.APIKeys.List(ctx, query) (*Page[BetaAPIKey], error)
GET/v1/organizations/api_keys
Recupera chiave API (Admin API)
client.Beta.Organization.APIKeys.Get(ctx, apiKeyID) (*BetaAPIKey, error)
GET/v1/organizations/api_keys/{api_key_id}

Recupera le informazioni su una singola chiave API della tua organizzazione, cercata tramite il suo ID. Questo endpoint dell'Admin API richiede una chiave Admin API, è pensato per la gestione programmatica delle chiavi e non restituisce mai il valore segreto della chiave. Per visualizzare o creare le tue chiavi API, vai su Chiavi API nella Claude Console.

Aggiorna chiave API
client.Beta.Organization.APIKeys.Update(ctx, apiKeyID, body) (*BetaAPIKey, error)
POST/v1/organizations/api_keys/{api_key_id}

BetaOrganizzazioneChiavi esterne

Crea chiave esterna
client.Beta.Organization.ExternalKeys.New(ctx, body) (*BetaExternalKey, error)
POST/v1/organizations/external_keys

Crea una configurazione di chiave esterna di proprietà dell'organizzazione del chiamante.

Elenca le chiavi esterne
client.Beta.Organization.ExternalKeys.List(ctx, query) (*PageCursor[BetaExternalKey], error)
GET/v1/organizations/external_keys

Elenca le configurazioni di chiavi esterne nell'organizzazione del chiamante.

Ottieni chiave esterna
client.Beta.Organization.ExternalKeys.Get(ctx, externalKeyID) (*BetaExternalKey, error)
GET/v1/organizations/external_keys/{external_key_id}

Recupera una singola configurazione di chiave esterna nell'organizzazione del chiamante tramite ID.

Aggiorna chiave esterna
client.Beta.Organization.ExternalKeys.Update(ctx, externalKeyID, body) (*BetaExternalKey, error)
POST/v1/organizations/external_keys/{external_key_id}

Aggiorna parzialmente una configurazione di chiave esterna. I campi omessi restano invariati.

Elimina chiave esterna
client.Beta.Organization.ExternalKeys.Delete(ctx, externalKeyID) (*BetaOrganizationExternalKeyDeleteResponse, error)
DELETE/v1/organizations/external_keys/{external_key_id}

Elimina una configurazione di chiave esterna.

Convalida chiave esterna
client.Beta.Organization.ExternalKeys.Validate(ctx, externalKeyID) (*BetaOrganizationExternalKeyValidateResponse, error)
POST/v1/organizations/external_keys/{external_key_id}/validate

Convalida una configurazione di chiave esterna rispetto al KMS del cliente.

BetaOrganizzazioneFederazioneEmittenti

Crea emittente di federazione
client.Beta.Organization.Federation.Issuers.New(ctx, params) (*BetaFederationIssuer, error)
POST/v1/organizations/federation_issuers

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Elenca gli emittenti di federazione
client.Beta.Organization.Federation.Issuers.List(ctx, params) (*PageCursor[BetaFederationIssuer], error)
GET/v1/organizations/federation_issuers

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Ottieni emittente di federazione
client.Beta.Organization.Federation.Issuers.Get(ctx, federationIssuerID, query) (*BetaFederationIssuer, error)
GET/v1/organizations/federation_issuers/{federation_issuer_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Aggiorna emittente di federazione
client.Beta.Organization.Federation.Issuers.Update(ctx, federationIssuerID, params) (*BetaFederationIssuer, error)
POST/v1/organizations/federation_issuers/{federation_issuer_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Archivia emittente di federazione
client.Beta.Organization.Federation.Issuers.Archive(ctx, federationIssuerID, body) (*BetaFederationIssuer, error)
POST/v1/organizations/federation_issuers/{federation_issuer_id}/archive

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

BetaOrganizzazioneFederazioneRegole

Crea regola di federazione
client.Beta.Organization.Federation.Rules.New(ctx, params) (*BetaFederationRule, error)
POST/v1/organizations/federation_rules

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Elenca le regole di federazione
client.Beta.Organization.Federation.Rules.List(ctx, params) (*PageCursor[BetaFederationRule], error)
GET/v1/organizations/federation_rules

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Ottieni regola di federazione
client.Beta.Organization.Federation.Rules.Get(ctx, federationRuleID, query) (*BetaFederationRule, error)
GET/v1/organizations/federation_rules/{federation_rule_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Aggiorna regola di federazione
client.Beta.Organization.Federation.Rules.Update(ctx, federationRuleID, params) (*BetaFederationRule, error)
POST/v1/organizations/federation_rules/{federation_rule_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Archivia regola di federazione
client.Beta.Organization.Federation.Rules.Archive(ctx, federationRuleID, body) (*BetaFederationRule, error)
POST/v1/organizations/federation_rules/{federation_rule_id}/archive

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

BetaOrganizzazioneFederazioneRegoleWorkspace

Aggiungi workspace alla regola di federazione
client.Beta.Organization.Federation.Rules.Workspaces.Add(ctx, federationRuleID, params) (*BetaFederationRuleWorkspace, error)
POST/v1/organizations/federation_rules/{federation_rule_id}/workspaces

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Elenca i workspace della regola di federazione
client.Beta.Organization.Federation.Rules.Workspaces.List(ctx, federationRuleID, params) (*PageCursor[BetaFederationRuleWorkspace], error)
GET/v1/organizations/federation_rules/{federation_rule_id}/workspaces

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Rimuovi workspace dalla regola di federazione
client.Beta.Organization.Federation.Rules.Workspaces.Remove(ctx, workspaceID, params) (*BetaOrganizationFederationRuleWorkspaceRemoveResponse, error)
DELETE/v1/organizations/federation_rules/{federation_rule_id}/workspaces/{workspace_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

BetaOrganizzazioneInviti

Crea invito
client.Beta.Organization.Invites.New(ctx, body) (*BetaOrganizationInvite, error)
POST/v1/organizations/invites

Invita un utente a unirsi all'organizzazione tramite email.

Elenca gli inviti
client.Beta.Organization.Invites.List(ctx, query) (*Page[BetaOrganizationInvite], error)
GET/v1/organizations/invites

Elenca gli inviti dell'organizzazione.

Ottieni invito
client.Beta.Organization.Invites.Get(ctx, inviteID) (*BetaOrganizationInvite, error)
GET/v1/organizations/invites/{invite_id}

Recupera un invito tramite ID.

Elimina invito
client.Beta.Organization.Invites.Delete(ctx, inviteID) (*BetaOrganizationInviteDeleteResponse, error)
DELETE/v1/organizations/invites/{invite_id}

Elimina un invito in sospeso.

BetaOrganizzazioneAccount di servizio

Crea account di servizio
client.Beta.Organization.ServiceAccounts.New(ctx, params) (*BetaServiceAccount, error)
POST/v1/organizations/service_accounts

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Elenca gli account di servizio
client.Beta.Organization.ServiceAccounts.List(ctx, params) (*PageCursor[BetaServiceAccount], error)
GET/v1/organizations/service_accounts

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Ottieni account di servizio
client.Beta.Organization.ServiceAccounts.Get(ctx, serviceAccountID, query) (*BetaServiceAccount, error)
GET/v1/organizations/service_accounts/{service_account_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Aggiorna account di servizio
client.Beta.Organization.ServiceAccounts.Update(ctx, serviceAccountID, params) (*BetaServiceAccount, error)
POST/v1/organizations/service_accounts/{service_account_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Archivia account di servizio
client.Beta.Organization.ServiceAccounts.Archive(ctx, serviceAccountID, body) (*BetaServiceAccount, error)
POST/v1/organizations/service_accounts/{service_account_id}/archive

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

BetaOrganizzazioneAccount di servizioWorkspace

Aggiungi workspace all'account di servizio
client.Beta.Organization.ServiceAccounts.Workspaces.Add(ctx, serviceAccountID, params) (*BetaServiceAccountWorkspaceMember, error)
POST/v1/organizations/service_accounts/{service_account_id}/workspaces

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Elenca i workspace dell'account di servizio
client.Beta.Organization.ServiceAccounts.Workspaces.List(ctx, serviceAccountID, params) (*PageCursor[BetaServiceAccountWorkspaceMember], error)
GET/v1/organizations/service_accounts/{service_account_id}/workspaces

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Rimuovi workspace dall'account di servizio
client.Beta.Organization.ServiceAccounts.Workspaces.Remove(ctx, workspaceID, params) (*BetaOrganizationServiceAccountWorkspaceRemoveResponse, error)
DELETE/v1/organizations/service_accounts/{service_account_id}/workspaces/{workspace_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

BetaOrganizzazioneUtenti

Elenca gli utenti
client.Beta.Organization.Users.List(ctx, query) (*Page[BetaOrganizationUser], error)
GET/v1/organizations/users

Elenca i membri dell'organizzazione.

Ottieni utente
client.Beta.Organization.Users.Get(ctx, userID) (*BetaOrganizationUser, error)
GET/v1/organizations/users/{user_id}

Recupera un membro dell'organizzazione tramite ID utente.

Aggiorna utente
client.Beta.Organization.Users.Update(ctx, userID, body) (*BetaOrganizationUser, error)
POST/v1/organizations/users/{user_id}

Aggiorna il ruolo di un membro nell'organizzazione.

Rimuovi utente
client.Beta.Organization.Users.Remove(ctx, userID) (*BetaOrganizationUserRemoveResponse, error)
DELETE/v1/organizations/users/{user_id}

Rimuovi un membro dall'organizzazione.

BetaOrganizzazioneWorkspace

Elenca i workspace
client.Beta.Organization.Workspaces.List(ctx, query) (*Page[BetaWorkspace], error)
GET/v1/organizations/workspaces
Crea workspace
client.Beta.Organization.Workspaces.New(ctx, params) (*BetaWorkspace, error)
POST/v1/organizations/workspaces
Ottieni workspace
client.Beta.Organization.Workspaces.Get(ctx, workspaceID) (*BetaWorkspace, error)
GET/v1/organizations/workspaces/{workspace_id}
Aggiorna workspace
client.Beta.Organization.Workspaces.Update(ctx, workspaceID, body) (*BetaWorkspace, error)
POST/v1/organizations/workspaces/{workspace_id}
Archivia workspace
client.Beta.Organization.Workspaces.Archive(ctx, workspaceID) (*BetaWorkspace, error)
POST/v1/organizations/workspaces/{workspace_id}/archive

BetaOrganizzazioneWorkspaceLimiti di velocità

Elenca i limiti di velocità del workspace
client.Beta.Organization.Workspaces.RateLimits.List(ctx, workspaceID, query) (*PageCursor[BetaWorkspaceRateLimit], error)
GET/v1/organizations/workspaces/{workspace_id}/rate_limits

Elenca i "rate limit" (limiti di velocità) di un workspace.

BetaOrganizzazioneWorkspaceMembri

Elenca i membri del workspace
client.Beta.Organization.Workspaces.Members.List(ctx, workspaceID, query) (*Page[BetaWorkspaceMember], error)
GET/v1/organizations/workspaces/{workspace_id}/members
Crea membro del workspace
client.Beta.Organization.Workspaces.Members.Add(ctx, workspaceID, body) (*BetaWorkspaceMember, error)
POST/v1/organizations/workspaces/{workspace_id}/members
Ottieni membro del workspace
client.Beta.Organization.Workspaces.Members.Get(ctx, userID, query) (*BetaWorkspaceMember, error)
GET/v1/organizations/workspaces/{workspace_id}/members/{user_id}
Aggiorna membro del workspace
client.Beta.Organization.Workspaces.Members.Update(ctx, userID, params) (*BetaWorkspaceMember, error)
POST/v1/organizations/workspaces/{workspace_id}/members/{user_id}
Elimina membro del workspace
client.Beta.Organization.Workspaces.Members.Remove(ctx, userID, body) (*BetaOrganizationWorkspaceMemberRemoveResponse, error)
DELETE/v1/organizations/workspaces/{workspace_id}/members/{user_id}

BetaOrganizzazioneWorkspaceAccount di servizio

Elenca gli account di servizio membri del workspace
client.Beta.Organization.Workspaces.ServiceAccounts.List(ctx, workspaceID, params) (*PageCursor[BetaServiceAccountWorkspaceMember], error)
GET/v1/organizations/workspaces/{workspace_id}/service_accounts

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Crea account di servizio membro del workspace
client.Beta.Organization.Workspaces.ServiceAccounts.Add(ctx, workspaceID, params) (*BetaServiceAccountWorkspaceMember, error)
POST/v1/organizations/workspaces/{workspace_id}/service_accounts

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Ottieni account di servizio membro del workspace
client.Beta.Organization.Workspaces.ServiceAccounts.Get(ctx, serviceAccountID, params) (*BetaServiceAccountWorkspaceMember, error)
GET/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Aggiorna account di servizio membro del workspace
client.Beta.Organization.Workspaces.ServiceAccounts.Update(ctx, serviceAccountID, params) (*BetaServiceAccountWorkspaceMember, error)
POST/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi Admin API non sono accettate. Consulta Gestire WIF con l'Admin API.

Elimina account di servizio membro del workspace
client.Beta.Organization.Workspaces.ServiceAccounts.Remove(ctx, serviceAccountID, params) (*BetaOrganizationWorkspaceServiceAccountRemoveResponse, error)
DELETE/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}

Richiede un token di accesso OAuth con lo scope org:admin, ottenuto da ant auth login --scope org:admin o da una regola di workload identity federation; le chiavi API Admin non sono accettate. Consulta Gestire WIF con l'Admin API.

BetaOrganizzazioneLimiti di velocità

Elenca i limiti di velocità dell'organizzazione
client.Beta.Organization.RateLimits.List(ctx, query) (*PageCursor[BetaOrganizationRateLimit], error)
GET/v1/organizations/rate_limits

Elenca i "rate limit" (limiti di velocità) della Messages API per la tua organizzazione.

BetaOrganizzazioneImpostazioni di conformità

Ottieni le impostazioni di conformità
client.Beta.Organization.ComplianceSettings.Get(ctx) (*BetaComplianceSettings, error)
GET/v1/organizations/compliance_settings

Recupera le impostazioni di conformità (Compliance Settings) della tua organizzazione.

Aggiorna le impostazioni di conformità
client.Beta.Organization.ComplianceSettings.Update(ctx, body) (*BetaComplianceSettings, error)
POST/v1/organizations/compliance_settings

Aggiorna le impostazioni di conformità (Compliance Settings) della tua organizzazione.

BetaOrganizzazioneAnalisiRiepiloghi

Ottieni riepiloghi delle attività
client.Beta.Organization.Analytics.Summaries.List(ctx, query) (*PageCursor[BetaAnalyticsSingleDayActivitySummary], error)
GET/v1/organizations/analytics/summaries

Ottieni i riepiloghi delle attività a livello di organizzazione per un intervallo di date.

BetaOrganizzazioneAnalisiUtenti

Elenca attività utente
client.Beta.Organization.Analytics.Users.List(ctx, query) (*PageCursor[BetaAnalyticsUserActivity], error)
GET/v1/organizations/analytics/users

Ottieni l'attività per utente per un determinato giorno, con paginazione basata su cursore.

BetaOrganizzazioneAnalisiAppChatProgetti

Ottieni utilizzo dei progetti di chat
client.Beta.Organization.Analytics.Apps.Chat.Projects.List(ctx, query) (*PageCursor[BetaAnalyticsProjectActivity], error)
GET/v1/organizations/analytics/apps/chat/projects

Ottieni l'attività per progetto per un determinato giorno, con paginazione basata su cursore.

BetaOrganizzazioneAnalisiConnettori

Ottieni utilizzo dei connettori
client.Beta.Organization.Analytics.Connectors.List(ctx, query) (*PageCursor[BetaAnalyticsConnectorActivity], error)
GET/v1/organizations/analytics/connectors

Ottieni l'utilizzo per connettore per un determinato giorno, con paginazione basata su cursore.

BetaOrganizzazioneAnalisiPlugin

Ottieni utilizzo dei plugin
client.Beta.Organization.Analytics.Plugins.List(ctx, query) (*PageCursor[BetaAnalyticsPluginActivity], error)
GET/v1/organizations/analytics/plugins

Ottieni l'utilizzo di installazione + invocazione per plugin per un determinato giorno, con paginazione.

BetaOrganizzazioneAnalisiSkill

Ottieni utilizzo delle skill
client.Beta.Organization.Analytics.Skills.List(ctx, query) (*PageCursor[BetaAnalyticsSkillActivity], error)
GET/v1/organizations/analytics/skills

Ottieni l'utilizzo per skill per un determinato giorno, con paginazione basata su cursore.

BetaOrganizzazioneAnalisiArtifacts

Ottieni attività degli artifact
client.Beta.Organization.Analytics.Artifacts.List(ctx, query) (*PageCursor[BetaAnalyticsArtifactActivity], error)
GET/v1/organizations/analytics/artifacts

Ottieni l'attività di creazione di artifact per un determinato giorno, suddivisa per tipo MIME.

BetaOrganizzazioneAnalisiReport di utilizzo

Ottieni utilizzo dei token nel tempo
client.Beta.Organization.Analytics.UsageReport.List(ctx, query) (*PageCursor[BetaAnalyticsUsageReportTimeBucket], error)
GET/v1/organizations/analytics/usage_report

Ottieni l'utilizzo dei token nel tempo in un intervallo di date.

BetaOrganizzazioneAnalisiReport di utilizzo per utente

Ottieni utilizzo dei token per utente
client.Beta.Organization.Analytics.UserUsageReport.List(ctx, query) (*PageCursor[BetaAnalyticsUsageUsersItem], error)
GET/v1/organizations/analytics/user_usage_report

Ottieni l'utilizzo dei token per utente in un intervallo di date.

BetaOrganizzazioneAnalisiReport dei costi

Ottieni costi nel tempo
client.Beta.Organization.Analytics.CostReport.List(ctx, query) (*PageCursor[BetaAnalyticsCostReportTimeBucket], error)
GET/v1/organizations/analytics/cost_report

Ottieni il costo in USD nel tempo in un intervallo di date.

BetaOrganizzazioneAnalisiReport dei costi per utente

Ottieni costi per utente
client.Beta.Organization.Analytics.UserCostReport.List(ctx, query) (*PageCursor[BetaAnalyticsCostUsersItem], error)
GET/v1/organizations/analytics/user_cost_report

Ottieni il costo per utente in USD in un intervallo di date.

BetaOrganizzazioneLimiti di spesa

Imposta limite di spesa
client.Beta.Organization.SpendLimits.Set(ctx, params) (*BetaSpendLimit, error)
POST/v1/organizations/spend_limits

Imposta un limite di spesa.

Ottieni limite di spesa
client.Beta.Organization.SpendLimits.Get(ctx, spendLimitID) (*BetaSpendLimit, error)
GET/v1/organizations/spend_limits/{spend_limit_id}

Recupera un limite di spesa tramite ID.

Elimina limite di spesa
client.Beta.Organization.SpendLimits.Delete(ctx, spendLimitID) (*BetaOrganizationSpendLimitDeleteResponse, error)
DELETE/v1/organizations/spend_limits/{spend_limit_id}

Elimina un limite di spesa.

Elenca limiti di spesa
client.Beta.Organization.SpendLimits.List(ctx, params) (*PageCursor[BetaSpendLimit], error)
GET/v1/organizations/spend_limits

Elenca i limiti di spesa dell'organizzazione.

BetaOrganizzazioneLimiti di spesaEffettivi

Elenca limiti di spesa effettivi
client.Beta.Organization.SpendLimits.Effective.List(ctx, query) (*PageCursor[BetaSpendSummary], error)
GET/v1/organizations/spend_limits/effective

Elenca il limite di spesa effettivo e la spesa dall'inizio del periodo di ciascun membro.

BetaOrganizzazioneLimiti di spesaRichieste di aumento

Elenca richieste di aumento del limite di spesa
client.Beta.Organization.SpendLimits.IncreaseRequests.List(ctx, query) (*PageCursor[BetaSpendLimitIncreaseRequest], error)
GET/v1/organizations/spend_limit_increase_requests

Elenca le richieste di aumento del limite di spesa, dalla più recente.

Ottieni richiesta di aumento del limite di spesa
client.Beta.Organization.SpendLimits.IncreaseRequests.Get(ctx, spendLimitIncreaseRequestID) (*BetaSpendLimitIncreaseRequest, error)
GET/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}

Recupera una richiesta di aumento del limite di spesa.

Approva richiesta di aumento del limite di spesa
client.Beta.Organization.SpendLimits.IncreaseRequests.Approve(ctx, spendLimitIncreaseRequestID, body) (*BetaOrganizationSpendLimitIncreaseRequestApproveResponse, error)
POST/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}/approve

Approva una richiesta di aumento del limite di spesa in sospeso.

Rifiuta richiesta di aumento del limite di spesa
client.Beta.Organization.SpendLimits.IncreaseRequests.Deny(ctx, spendLimitIncreaseRequestID, body) (*BetaSpendLimitIncreaseRequest, error)
POST/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}/deny

Rifiuta una richiesta di aumento del limite di spesa in sospeso.

BetaOrganizzazioneGruppi RBAC

Crea gruppo RBAC
client.Beta.Organization.RBACGroups.New(ctx, body) (*BetaRBACGroup, error)
POST/v1/organizations/rbac_groups

Crea un gruppo RBAC nel tenant Claude Enterprise. I gruppi creati tramite l'API hanno tipo di origine "direct".

Elenca gruppi RBAC
client.Beta.Organization.RBACGroups.List(ctx, query) (*PageCursor[BetaRBACGroup], error)
GET/v1/organizations/rbac_groups

Elenca i gruppi RBAC nel tenant Claude Enterprise.

Ottieni gruppo RBAC
client.Beta.Organization.RBACGroups.Get(ctx, rbacGroupID) (*BetaRBACGroup, error)
GET/v1/organizations/rbac_groups/{rbac_group_id}

Recupera un gruppo RBAC tramite ID.

Aggiorna gruppo RBAC
client.Beta.Organization.RBACGroups.Update(ctx, rbacGroupID, body) (*BetaRBACGroup, error)
POST/v1/organizations/rbac_groups/{rbac_group_id}

Aggiorna il nome di un gruppo RBAC. I gruppi forniti da un provider di identità (tipo di origine "scim") non possono essere modificati tramite l'API mentre un'organizzazione nel tenant usa il provisioning SCIM.

Elimina gruppo RBAC
client.Beta.Organization.RBACGroups.Delete(ctx, rbacGroupID) (*BetaOrganizationRBACGroupDeleteResponse, error)
DELETE/v1/organizations/rbac_groups/{rbac_group_id}

Elimina un gruppo RBAC. I gruppi forniti da un provider di identità (tipo di origine "scim") non possono essere eliminati tramite l'API mentre un'organizzazione nel tenant usa il provisioning SCIM.

BetaOrganizzazioneGruppi RBACMembri

Elenca membri del gruppo RBAC
client.Beta.Organization.RBACGroups.Members.List(ctx, rbacGroupID, query) (*PageCursor[BetaRBACGroupMember], error)
GET/v1/organizations/rbac_groups/{rbac_group_id}/members

Elenca i membri di un gruppo RBAC.

Aggiungi membro al gruppo RBAC
client.Beta.Organization.RBACGroups.Members.Add(ctx, rbacGroupID, body) (*BetaRBACGroupMember, error)
POST/v1/organizations/rbac_groups/{rbac_group_id}/members

Aggiunge un utente a un gruppo RBAC. L'appartenenza ai gruppi forniti da un identity provider (tipo di origine "scim") non può essere modificata tramite l'API mentre un'organizzazione nel tenant usa il provisioning SCIM.

Rimuovi membro dal gruppo RBAC
client.Beta.Organization.RBACGroups.Members.Remove(ctx, userID, body) (*BetaOrganizationRBACGroupMemberRemoveResponse, error)
DELETE/v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}

Rimuove un utente da un gruppo RBAC. L'appartenenza ai gruppi forniti da un identity provider (tipo di origine "scim") non può essere modificata tramite l'API mentre un'organizzazione nel tenant usa il provisioning SCIM.

BetaOrganizzazioneRuoli RBAC

Elenca ruoli RBAC
client.Beta.Organization.RBACRoles.List(ctx, query) (*PageCursor[BetaRBACRole], error)
GET/v1/organizations/rbac_roles

Elenca i ruoli RBAC nell'organizzazione.

Ottieni ruolo RBAC
client.Beta.Organization.RBACRoles.Get(ctx, rbacRoleID) (*BetaRBACRole, error)
GET/v1/organizations/rbac_roles/{rbac_role_id}

Recupera un ruolo RBAC tramite ID.

BetaOrganizzazioneRuoli RBACAutorizzazioni

Elenca autorizzazioni del ruolo RBAC
client.Beta.Organization.RBACRoles.Permissions.List(ctx, rbacRoleID, query) (*PageCursor[BetaRBACRolePermission], error)
GET/v1/organizations/rbac_roles/{rbac_role_id}/permissions

Elenca le autorizzazioni concesse da un ruolo RBAC.

BetaOrganizzazionePlugin

Crea plugin
client.Beta.Organization.Plugins.New(ctx, params) (*BetaPlugin, error)
POST/v1/organizations/plugins

Crea un plugin di proprietà dell'organizzazione e la sua prima versione caricando i file della versione.

Ottieni plugin
client.Beta.Organization.Plugins.Get(ctx, pluginID, params) (*BetaPlugin, error)
GET/v1/organizations/plugins/{plugin_id}

Recupera un plugin tramite ID.

Aggiorna plugin
client.Beta.Organization.Plugins.Update(ctx, pluginID, params) (*BetaPlugin, error)
POST/v1/organizations/plugins/{plugin_id}

Cambia quale versione archiviata di un Plugin di proprietà dell'organizzazione viene servita ai membri, ad esempio per tornare a una versione precedente. Questa operazione fissa la versione servita: i caricamenti successivi vengono archiviati ma non cambiano più ciò che viene servito, e al momento il fissaggio non può essere annullato, né qui né in claude.ai.

Elenca i Plugin
client.Beta.Organization.Plugins.List(ctx, params) (*PageCursor[BetaPlugin], error)
GET/v1/organizations/plugins

Elenca i Plugin creati nell'organizzazione, dal più recente: quelli nei marketplace di plugin dell'organizzazione e quelli nei marketplace di plugin personali dei membri.

Elimina Plugin
client.Beta.Organization.Plugins.Delete(ctx, pluginID, body) (*BetaDeletedPlugin, error)
DELETE/v1/organizations/plugins/{plugin_id}

Elimina definitivamente un Plugin e tutte le sue versioni, esattamente come quando un amministratore lo elimina in claude.ai. Il Plugin può appartenere all'organizzazione o a un membro, incluso un membro che nel frattempo ha lasciato l'organizzazione.

BetaOrganizzazionePluginVersioni

Crea versione del Plugin
client.Beta.Organization.Plugins.Versions.New(ctx, pluginID, params) (*BetaPluginVersion, error)
POST/v1/organizations/plugins/{plugin_id}/versions

Aggiungi una versione a un Plugin di proprietà dell'organizzazione caricando i file della nuova versione; diventa la versione servita ai membri a meno che la versione servita del Plugin non sia stata fissata.

Elenca le versioni del Plugin
client.Beta.Organization.Plugins.Versions.List(ctx, pluginID, params) (*PageCursor[BetaPluginVersion], error)
GET/v1/organizations/plugins/{plugin_id}/versions

Elenca le versioni di un Plugin, dalla più recente.

Ottieni versione del Plugin
client.Beta.Organization.Plugins.Versions.Get(ctx, version, params) (*BetaPluginVersion, error)
GET/v1/organizations/plugins/{plugin_id}/versions/{version}

Recupera una versione di un Plugin tramite il suo ID, oppure la versione più recente del Plugin.

Scarica l'archivio della versione del Plugin
client.Beta.Organization.Plugins.Versions.Download(ctx, version, params) (*Response, error)
GET/v1/organizations/plugins/{plugin_id}/versions/{version}/content

Scarica l'archivio .zip di una versione, esattamente come è archiviato. Ogni download di un Plugin dal marketplace di plugin personale di un membro viene registrato nel feed delle attività della Compliance API.

BetaOrganizzazionePluginImpostazioni di installazione

Elenca le impostazioni di installazione del Plugin
client.Beta.Organization.Plugins.InstallationSettings.List(ctx, pluginID, params) (*PageCursor[BetaPluginInstallationSetting], error)
GET/v1/organizations/plugins/{plugin_id}/installation_settings

Elenca le impostazioni di installazione di un Plugin di proprietà dell'organizzazione, che indicano a quali membri è destinato, dalla creata più di recente.

Imposta l'impostazione di installazione del Plugin
client.Beta.Organization.Plugins.InstallationSettings.Set(ctx, target, params) (*BetaPluginInstallationSetting, error)
POST/v1/organizations/plugins/{plugin_id}/installation_settings/{target}

Imposta o modifica l'impostazione di installazione di un Plugin di proprietà dell'organizzazione per l'intera organizzazione o per un gruppo RBAC.

Rimuovi l'impostazione di installazione del Plugin
client.Beta.Organization.Plugins.InstallationSettings.Remove(ctx, target, params) (*BetaDeletedPluginInstallationSetting, error)
DELETE/v1/organizations/plugins/{plugin_id}/installation_settings/{target}

Rimuovi l'impostazione di installazione propria di un Plugin di proprietà dell'organizzazione per l'intera organizzazione o per un gruppo RBAC.

BetaOrganizzazionePluginCondivisioni

Elenca le condivisioni del Plugin
client.Beta.Organization.Plugins.Shares.List(ctx, pluginID, params) (*PageCursor[BetaPluginShare], error)
GET/v1/organizations/plugins/{plugin_id}/shares

Elenca le condivisioni concesse dal proprietario di un Plugin di proprietà di un membro — a tutti i membri dell'organizzazione, a un gruppo RBAC o a un singolo membro — dalla concessa più di recente.

BetaOrganizzazioneMarketplace di plugin

Elenca i marketplace di plugin
client.Beta.Organization.PluginMarketplaces.List(ctx, params) (*PageCursor[BetaPluginMarketplace], error)
GET/v1/organizations/plugin_marketplaces

Elenca i marketplace di plugin in cui si trovano i Plugin, dal più recente: quelli dell'organizzazione e quelli personali dei suoi membri.

Ottieni marketplace di plugin
client.Beta.Organization.PluginMarketplaces.Get(ctx, marketplaceID, params) (*BetaPluginMarketplace, error)
GET/v1/organizations/plugin_marketplaces/{marketplace_id}

Recupera un marketplace di plugin tramite ID.

Aggiorna marketplace di plugin
client.Beta.Organization.PluginMarketplaces.Update(ctx, marketplaceID, params) (*BetaPluginMarketplace, error)
POST/v1/organizations/plugin_marketplaces/{marketplace_id}

Imposta l'impostazione di installazione predefinita di uno dei marketplace di plugin dell'organizzazione. Ogni Plugin al suo interno senza un'impostazione propria riceve questo valore predefinito come impostazione a livello di organizzazione, inclusi i Plugin aggiunti in seguito.

Convalida repository del marketplace di plugin
client.Beta.Organization.PluginMarketplaces.ValidateRepository(ctx, params) (*BetaPluginMarketplaceValidationReport, error)
POST/v1/organizations/plugin_marketplaces/validate_repository

Verifica se un marketplace di plugin contenuto in un repository GitHub pubblico verrebbe sincronizzato in claude.ai, senza collegarlo né archiviarlo.

Convalida archivio del marketplace di plugin
client.Beta.Organization.PluginMarketplaces.ValidateArchive(ctx, params) (*BetaPluginMarketplaceValidationReport, error)
POST/v1/organizations/plugin_marketplaces/validate_archive

Verifica se un marketplace di plugin, caricato come .zip della directory del marketplace, verrebbe sincronizzato in claude.ai, senza collegarlo né archiviarlo.

BetaOrganizzazioneDestinazioni di telemetria

Crea una destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.New(ctx, params) (*BetaTelemetryDestination, error)
POST/v1/organizations/telemetry_destinations

Registra una destinazione OpenTelemetry per l'organizzazione.

Elenca destinazioni di telemetria
client.Beta.Organization.TelemetryDestinations.List(ctx, params) (*PageCursor[BetaTelemetryDestination], error)
GET/v1/organizations/telemetry_destinations

Elenca le destinazioni dell'organizzazione, dalla più recente, facoltativamente solo quelle che coprono determinati workspace.

Recupera una destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.Get(ctx, destinationID, query) (*BetaTelemetryDestination, error)
GET/v1/organizations/telemetry_destinations/{destination_id}

Leggi la configurazione, lo stato e i risultati di consegna più recenti di una destinazione.

Aggiorna una destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.Update(ctx, destinationID, params) (*BetaTelemetryDestination, error)
POST/v1/organizations/telemetry_destinations/{destination_id}

Modifica le impostazioni di una destinazione di telemetria, il suo stato o i workspace che copre.

Elimina una destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.Delete(ctx, destinationID, body) (*BetaDeletedTelemetryDestination, error)
DELETE/v1/organizations/telemetry_destinations/{destination_id}

Elimina una destinazione e il relativo elenco di workspace.

Testa una destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.Test(ctx, destinationID, body) (*BetaTelemetryDestinationTestResponse, error)
POST/v1/organizations/telemetry_destinations/{destination_id}/test

Invia uno span di test, denominato anthropic.test, alla destinazione con i suoi header registrati, una sola volta e senza nuovi tentativi, e riporta la risposta della destinazione. La risposta è 200 indipendentemente dal fatto che la destinazione abbia risposto con uno stato 2xx: il suo result ha il tipo success, oppure il tipo failure con il motivo in error. La configurazione, lo state e il delivery_health della destinazione non cambiano. È possibile testare anche una destinazione disabilitata. Attendi 10 secondi tra un test e l'altro della stessa destinazione; una richiesta che arriva prima può ricevere lo stato 429.

BetaOrganizzazioneDestinazioni di telemetriaWorkspace

Elenca i workspace della destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.Workspaces.List(ctx, destinationID, params) (*PageCursor[BetaTelemetryDestinationWorkspace], error)
GET/v1/organizations/telemetry_destinations/{destination_id}/workspaces

Elenca i workspace presenti nell'elenco dei workspace di una destinazione, a partire dalla voce più recente.

Aggiungi un workspace alla destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.Workspaces.Add(ctx, workspaceID, params) (*BetaTelemetryDestinationWorkspace, error)
POST/v1/organizations/telemetry_destinations/{destination_id}/workspaces/{workspace_id}

Aggiungi un workspace all'elenco dei workspace di una destinazione.

Rimuovi un workspace dalla destinazione di telemetria
client.Beta.Organization.TelemetryDestinations.Workspaces.Remove(ctx, workspaceID, params) (*BetaDeletedTelemetryDestinationWorkspace, error)
DELETE/v1/organizations/telemetry_destinations/{destination_id}/workspaces/{workspace_id}

Rimuovi un workspace dall'elenco dei workspace di una destinazione.