Claude Platform Docs

Beta

Models
type AnthropicBeta = (string & {}) | "message-batches-2024-09-24" | "prompt-caching-2024-07-31" | "computer-use-2024-10-22" | 47 more
One of the following:
interface BetaAPIError { type: "api_error"; message }
type: "api_error"
defaultapi_error
message: string
defaultInternal server error
interface BetaAuthenticationError { type: "authentication_error"; message }
type: "authentication_error"
defaultauthentication_error
message: string
defaultAuthentication error
interface BetaBillingError { type: "billing_error"; message }
type: "billing_error"
defaultbilling_error
message: string
defaultBilling error
type BetaCurrency = "USD"
type BetaError = BetaInvalidRequestError | BetaAuthenticationError | BetaBillingError | 6 more
One of the following:
interface BetaErrorResponse { type: "error"; error; request_id }
type: "error"
defaulterror
error: BetaError
One of the following:
request_id: string | null
interface BetaGatewayTimeoutError { type: "timeout_error"; message }
type: "timeout_error"
defaulttimeout_error
message: string
defaultRequest timeout
interface BetaInvalidRequestError { type: "invalid_request_error"; message }
type: "invalid_request_error"
defaultinvalid_request_error
message: string
defaultInvalid request
interface BetaMonetaryAmount { 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.

interface BetaNotFoundError { type: "not_found_error"; message }
type: "not_found_error"
defaultnot_found_error
message: string
defaultNot found
interface BetaOverloadedError { type: "overloaded_error"; message }
type: "overloaded_error"
defaultoverloaded_error
message: string
defaultOverloaded
interface BetaPermissionError { type: "permission_error"; message }
type: "permission_error"
defaultpermission_error
message: string
defaultPermission denied
interface BetaRateLimitError { type: "rate_limit_error"; message }
type: "rate_limit_error"
defaultrate_limit_error
message: string
defaultRate limited

BetaModelle

Modelle auflisten
client.beta.models.list(params?, options?): Page<BetaModelInfo>
GET/v1/models

Liste verfügbare Modelle auf.

Ein Modell abrufen
client.beta.models.retrieve(modelID, params?, options?): BetaModelInfo
GET/v1/models/{model_id}

Rufe ein bestimmtes Modell ab.

BetaNachrichten

Eine Nachricht erstellen
client.beta.messages.create(params, options?): BetaMessage | Stream<BetaRawMessageStreamEvent>
POST/v1/messages

Sende eine strukturierte Liste von Eingabenachrichten mit Text- und/oder Bildinhalten, und das Modell generiert die nächste Nachricht in der Konversation.

Tokens in einer Nachricht zählen
client.beta.messages.countTokens(params, options?): BetaMessageTokensCount
POST/v1/messages/count_tokens

Zähle die Anzahl der Tokens in einer Nachricht.

BetaNachrichtenBatches

Einen Message Batch erstellen
client.beta.messages.batches.create(params, options?): BetaMessageBatch
POST/v1/messages/batches

Sende einen Batch von Anfragen zur Erstellung von Nachrichten.

Einen Message Batch abrufen
client.beta.messages.batches.retrieve(messageBatchID, params?, options?): BetaMessageBatch
GET/v1/messages/batches/{message_batch_id}

Dieser Endpunkt ist idempotent und kann verwendet werden, um den Abschluss eines Message Batch per Polling abzufragen. Um auf die Ergebnisse eines Message Batch zuzugreifen, sende eine Anfrage an die im Feld results_url der Antwort angegebene URL.

Message Batches auflisten
client.beta.messages.batches.list(params?, options?): Page<BetaMessageBatch>
GET/v1/messages/batches

Liste alle Message Batches innerhalb eines Workspace auf. Die zuletzt erstellten Batches werden zuerst zurückgegeben.

Einen Message Batch abbrechen
client.beta.messages.batches.cancel(messageBatchID, params?, options?): BetaMessageBatch
POST/v1/messages/batches/{message_batch_id}/cancel

Batches können jederzeit vor Ende der Verarbeitung abgebrochen werden. Sobald der Abbruch eingeleitet wurde, wechselt der Batch in den Zustand canceling; in dieser Zeit kann das System laufende, nicht unterbrechbare Anfragen noch abschließen, bevor der Abbruch finalisiert wird.

Einen Message Batch löschen
client.beta.messages.batches.delete(messageBatchID, params?, options?): BetaDeletedMessageBatch
DELETE/v1/messages/batches/{message_batch_id}

Lösche einen Message Batch.

Ergebnisse eines Message Batch abrufen
client.beta.messages.batches.results(messageBatchID, params?, options?): BetaMessageBatchIndividualResponse | Stream<BetaMessageBatchIndividualResponse>
GET/v1/messages/batches/{message_batch_id}/results

Streamt die Ergebnisse eines Message Batch als .jsonl-Datei.

BetaAgenten

Agent erstellen
client.beta.agents.create(params, options?): BetaManagedAgentsAgent
POST/v1/agents
Agenten auflisten
client.beta.agents.list(params?, options?): PageCursor<BetaManagedAgentsAgent>
GET/v1/agents
Agent abrufen
client.beta.agents.retrieve(agentID, params?, options?): BetaManagedAgentsAgent
GET/v1/agents/{agent_id}
Agent aktualisieren
client.beta.agents.update(agentID, params, options?): BetaManagedAgentsAgent
POST/v1/agents/{agent_id}
Agent archivieren
client.beta.agents.archive(agentID, params?, options?): BetaManagedAgentsAgent
POST/v1/agents/{agent_id}/archive

BetaAgentenVersionen

Agent-Versionen auflisten
client.beta.agents.versions.list(agentID, params?, options?): PageCursor<BetaManagedAgentsAgent>
GET/v1/agents/{agent_id}/versions

BetaUmgebungen

Umgebung erstellen
client.beta.environments.create(params, options?): BetaEnvironment
POST/v1/environments

Erstelle eine neue Umgebung mit der angegebenen Konfiguration.

Umgebungen auflisten
client.beta.environments.list(params?, options?): PageCursor<BetaEnvironment>
GET/v1/environments

Liste Umgebungen mit Unterstützung für Paginierung auf.

Umgebung abrufen
client.beta.environments.retrieve(environmentID, params?, options?): BetaEnvironment
GET/v1/environments/{environment_id}

Rufe eine bestimmte Umgebung anhand ihrer ID ab.

Umgebung aktualisieren
client.beta.environments.update(environmentID, params, options?): BetaEnvironment
POST/v1/environments/{environment_id}

Aktualisiere die Konfiguration einer bestehenden Umgebung.

Umgebung löschen
client.beta.environments.delete(environmentID, params?, options?): BetaEnvironmentDeleteResponse
DELETE/v1/environments/{environment_id}

Lösche eine Umgebung anhand ihrer ID. Gibt eine Bestätigung der Löschung zurück.

Umgebung archivieren
client.beta.environments.archive(environmentID, params?, options?): BetaEnvironment
POST/v1/environments/{environment_id}/archive

Archiviere eine Umgebung anhand ihrer ID. Archivierte Umgebungen können nicht zum Erstellen neuer Sessions verwendet werden.

BetaUmgebungenArbeit

Arbeitselement abrufen
client.beta.environments.work.retrieve(workID, params, options?): BetaSelfHostedWork
GET/v1/environments/{environment_id}/work/{work_id}

Hinweis: Diese Endpunkte werden automatisch vom vorgefertigten Environment-Worker aufgerufen, der in den SDKs und der CLI bereitgestellt wird, um Sessions mit selbst gehosteten Sandbox-Umgebungen zu orchestrieren. Sie sind hier als Referenz aufgeführt; du musst sie nicht direkt aufrufen.

Arbeit per Polling abfragen
client.beta.environments.work.poll(environmentID, params?, options?): BetaSelfHostedWork | null
GET/v1/environments/{environment_id}/work/poll

Hinweis: Diese Endpunkte werden automatisch vom vorgefertigten Environment-Worker aufgerufen, der in den SDKs und der CLI bereitgestellt wird, um Sessions mit selbst gehosteten Sandbox-Umgebungen zu orchestrieren. Sie sind hier als Referenz aufgeführt; du musst sie nicht direkt aufrufen.

Arbeit bestätigen
client.beta.environments.work.ack(workID, params, options?): BetaSelfHostedWork
POST/v1/environments/{environment_id}/work/{work_id}/ack

Hinweis: Diese Endpunkte werden automatisch vom vorgefertigten Environment-Worker aufgerufen, der in den SDKs und der CLI bereitgestellt wird, um Sessions mit selbst gehosteten Sandbox-Umgebungen zu orchestrieren. Sie sind hier als Referenz aufgeführt; du musst sie nicht direkt aufrufen.

Heartbeat aufzeichnen
client.beta.environments.work.heartbeat(workID, params, options?): BetaSelfHostedWorkHeartbeatResponse
POST/v1/environments/{environment_id}/work/{work_id}/heartbeat

Hinweis: Diese Endpunkte werden automatisch vom vorgefertigten Environment-Worker aufgerufen, der in den SDKs und der CLI bereitgestellt wird, um Sessions mit selbst gehosteten Sandbox-Umgebungen zu orchestrieren. Sie sind hier als Referenz aufgeführt; du musst sie nicht direkt aufrufen.

Arbeit stoppen
client.beta.environments.work.stop(workID, params, options?): BetaSelfHostedWork
POST/v1/environments/{environment_id}/work/{work_id}/stop

Hinweis: Diese Endpunkte werden automatisch vom vorgefertigten Environment-Worker aufgerufen, der in den SDKs und der CLI bereitgestellt wird, um Sessions mit selbst gehosteten Sandbox-Umgebungen zu orchestrieren. Sie sind hier als Referenz aufgeführt; du musst sie nicht direkt aufrufen.

Arbeitselemente auflisten
client.beta.environments.work.list(environmentID, params?, options?): PageCursor<BetaSelfHostedWork>
GET/v1/environments/{environment_id}/work

Hinweis: Diese Endpunkte werden automatisch vom vorgefertigten Environment-Worker aufgerufen, der in den SDKs und der CLI bereitgestellt wird, um Sessions mit selbst gehosteten Sandbox-Umgebungen zu orchestrieren. Sie sind hier als Referenz aufgeführt; du musst sie nicht direkt aufrufen.

Arbeitselement aktualisieren
client.beta.environments.work.update(workID, params, options?): BetaSelfHostedWork
POST/v1/environments/{environment_id}/work/{work_id}

Hinweis: Diese Endpunkte werden automatisch vom vorgefertigten Environment-Worker aufgerufen, der in den SDKs und der CLI bereitgestellt wird, um Sessions mit selbst gehosteten Sandbox-Umgebungen zu orchestrieren. Sie sind hier als Referenz aufgeführt; du musst sie nicht direkt aufrufen.

Warteschlangenstatistiken abrufen
client.beta.environments.work.stats(environmentID, params?, options?): BetaSelfHostedWorkQueueStats
GET/v1/environments/{environment_id}/work/stats

Rufe Statistiken über die Arbeitswarteschlange einer Umgebung ab.

BetaSitzungen

Session erstellen
client.beta.sessions.create(params, options?): BetaManagedAgentsSession
POST/v1/sessions
Sessions auflisten
client.beta.sessions.list(params?, options?): BidirectionalPageCursor<BetaManagedAgentsSession>
GET/v1/sessions
Session abrufen
client.beta.sessions.retrieve(sessionID, params?, options?): BetaManagedAgentsSession
GET/v1/sessions/{session_id}
Session aktualisieren
client.beta.sessions.update(sessionID, params, options?): BetaManagedAgentsSession
POST/v1/sessions/{session_id}
Session löschen
client.beta.sessions.delete(sessionID, params?, options?): BetaManagedAgentsDeletedSession
DELETE/v1/sessions/{session_id}
Session archivieren
client.beta.sessions.archive(sessionID, params?, options?): BetaManagedAgentsSession
POST/v1/sessions/{session_id}/archive

BetaSitzungenEvents

Events auflisten
client.beta.sessions.events.list(sessionID, params?, options?): PageCursor<BetaManagedAgentsSessionEvent>
GET/v1/sessions/{session_id}/events
Events senden
client.beta.sessions.events.send(sessionID, params, options?): BetaManagedAgentsSendSessionEvents
POST/v1/sessions/{session_id}/events
Events streamen
client.beta.sessions.events.stream(sessionID, params?, options?): BetaManagedAgentsStreamSessionEvents | Stream<BetaManagedAgentsStreamSessionEvents>
GET/v1/sessions/{session_id}/events/stream

BetaSitzungenRessourcen

Session-Ressource hinzufügen
client.beta.sessions.resources.add(sessionID, params, options?): BetaManagedAgentsFileResource
POST/v1/sessions/{session_id}/resources
Session-Ressourcen auflisten
client.beta.sessions.resources.list(sessionID, params?, options?): PageCursor<BetaManagedAgentsSessionResource>
GET/v1/sessions/{session_id}/resources
Session-Ressource abrufen
client.beta.sessions.resources.retrieve(resourceID, params, options?): ResourceRetrieveResponse
GET/v1/sessions/{session_id}/resources/{resource_id}
Session-Ressource aktualisieren
client.beta.sessions.resources.update(resourceID, params, options?): ResourceUpdateResponse
POST/v1/sessions/{session_id}/resources/{resource_id}
Session-Ressource löschen
client.beta.sessions.resources.delete(resourceID, params, options?): BetaManagedAgentsDeleteSessionResource
DELETE/v1/sessions/{session_id}/resources/{resource_id}

BetaSitzungenThreads

Session-Threads auflisten
client.beta.sessions.threads.list(sessionID, params?, options?): PageCursor<BetaManagedAgentsSessionThread>
GET/v1/sessions/{session_id}/threads
Session-Thread abrufen
client.beta.sessions.threads.retrieve(threadID, params, options?): BetaManagedAgentsSessionThread
GET/v1/sessions/{session_id}/threads/{thread_id}
Session-Thread archivieren
client.beta.sessions.threads.archive(threadID, params, options?): BetaManagedAgentsSessionThread
POST/v1/sessions/{session_id}/threads/{thread_id}/archive

BetaSitzungenThreadsEvents

Session-Thread-Events auflisten
client.beta.sessions.threads.events.list(threadID, params, options?): PageCursor<BetaManagedAgentsSessionEvent>
GET/v1/sessions/{session_id}/threads/{thread_id}/events
Session-Thread-Events streamen
client.beta.sessions.threads.events.stream(threadID, params, options?): BetaManagedAgentsStreamSessionThreadEvents | Stream<BetaManagedAgentsStreamSessionThreadEvents>
GET/v1/sessions/{session_id}/threads/{thread_id}/stream

BetaDeployments

Deployment erstellen
client.beta.deployments.create(params, options?): BetaManagedAgentsDeployment
POST/v1/deployments
Deployments auflisten
client.beta.deployments.list(params?, options?): PageCursor<BetaManagedAgentsDeployment>
GET/v1/deployments
Deployment abrufen
client.beta.deployments.retrieve(deploymentID, params?, options?): BetaManagedAgentsDeployment
GET/v1/deployments/{deployment_id}
Deployment aktualisieren
client.beta.deployments.update(deploymentID, params, options?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}
Deployment archivieren
client.beta.deployments.archive(deploymentID, params?, options?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}/archive
Deployment jetzt ausführen
client.beta.deployments.run(deploymentID, params?, options?): BetaManagedAgentsDeploymentRun
POST/v1/deployments/{deployment_id}/run
Deployment pausieren
client.beta.deployments.pause(deploymentID, params?, options?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}/pause
Deployment fortsetzen
client.beta.deployments.unpause(deploymentID, params?, options?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}/unpause

BetaDeployment-Runs

Deployment-Runs auflisten
client.beta.deploymentRuns.list(params?, options?): PageCursor<BetaManagedAgentsDeploymentRun>
GET/v1/deployment_runs
Deployment-Run abrufen
client.beta.deploymentRuns.retrieve(deploymentRunID, params?, options?): BetaManagedAgentsDeploymentRun
GET/v1/deployment_runs/{deployment_run_id}

BetaVaults

Vault erstellen
client.beta.vaults.create(params, options?): BetaManagedAgentsVault
POST/v1/vaults
Vaults auflisten
client.beta.vaults.list(params?, options?): PageCursor<BetaManagedAgentsVault>
GET/v1/vaults
Vault abrufen
client.beta.vaults.retrieve(vaultID, params?, options?): BetaManagedAgentsVault
GET/v1/vaults/{vault_id}
Vault aktualisieren
client.beta.vaults.update(vaultID, params, options?): BetaManagedAgentsVault
POST/v1/vaults/{vault_id}
Vault löschen
client.beta.vaults.delete(vaultID, params?, options?): BetaManagedAgentsDeletedVault
DELETE/v1/vaults/{vault_id}
Vault archivieren
client.beta.vaults.archive(vaultID, params?, options?): BetaManagedAgentsVault
POST/v1/vaults/{vault_id}/archive

BetaVaultsAnmeldedaten

Credential erstellen
client.beta.vaults.credentials.create(vaultID, params, options?): BetaManagedAgentsCredential
POST/v1/vaults/{vault_id}/credentials
Credentials auflisten
client.beta.vaults.credentials.list(vaultID, params?, options?): PageCursor<BetaManagedAgentsCredential>
GET/v1/vaults/{vault_id}/credentials
Credential abrufen
client.beta.vaults.credentials.retrieve(credentialID, params, options?): BetaManagedAgentsCredential
GET/v1/vaults/{vault_id}/credentials/{credential_id}
Credential aktualisieren
client.beta.vaults.credentials.update(credentialID, params, options?): BetaManagedAgentsCredential
POST/v1/vaults/{vault_id}/credentials/{credential_id}
Credential löschen
client.beta.vaults.credentials.delete(credentialID, params, options?): BetaManagedAgentsDeletedCredential
DELETE/v1/vaults/{vault_id}/credentials/{credential_id}
Credential archivieren
client.beta.vaults.credentials.archive(credentialID, params, options?): BetaManagedAgentsCredential
POST/v1/vaults/{vault_id}/credentials/{credential_id}/archive
Credential validieren
client.beta.vaults.credentials.mcpOAuthValidate(credentialID, params, options?): BetaManagedAgentsCredentialValidation
POST/v1/vaults/{vault_id}/credentials/{credential_id}/mcp_oauth_validate

BetaMemory Stores

Memory Store erstellen
client.beta.memoryStores.create(params, options?): BetaManagedAgentsMemoryStore
POST/v1/memory_stores
Memory Stores auflisten
client.beta.memoryStores.list(params?, options?): PageCursor<BetaManagedAgentsMemoryStore>
GET/v1/memory_stores
Memory Store abrufen
client.beta.memoryStores.retrieve(memoryStoreID, params?, options?): BetaManagedAgentsMemoryStore
GET/v1/memory_stores/{memory_store_id}
Memory Store aktualisieren
client.beta.memoryStores.update(memoryStoreID, params, options?): BetaManagedAgentsMemoryStore
POST/v1/memory_stores/{memory_store_id}
Memory Store löschen
client.beta.memoryStores.delete(memoryStoreID, params?, options?): BetaManagedAgentsDeletedMemoryStore
DELETE/v1/memory_stores/{memory_store_id}
Memory Store archivieren
client.beta.memoryStores.archive(memoryStoreID, params?, options?): BetaManagedAgentsMemoryStore
POST/v1/memory_stores/{memory_store_id}/archive

BetaMemory StoresMemories

Memory erstellen
client.beta.memoryStores.memories.create(memoryStoreID, params, options?): BetaManagedAgentsMemory
POST/v1/memory_stores/{memory_store_id}/memories
Memories auflisten
client.beta.memoryStores.memories.list(memoryStoreID, params?, options?): PageCursor<BetaManagedAgentsMemoryListItem>
GET/v1/memory_stores/{memory_store_id}/memories
Memory abrufen
client.beta.memoryStores.memories.retrieve(memoryID, params, options?): BetaManagedAgentsMemory
GET/v1/memory_stores/{memory_store_id}/memories/{memory_id}
Memory aktualisieren
client.beta.memoryStores.memories.update(memoryID, params, options?): BetaManagedAgentsMemory
POST/v1/memory_stores/{memory_store_id}/memories/{memory_id}
Memory löschen
client.beta.memoryStores.memories.delete(memoryID, params, options?): BetaManagedAgentsDeletedMemory
DELETE/v1/memory_stores/{memory_store_id}/memories/{memory_id}

BetaMemory StoresMemory-Versionen

Memory-Versionen auflisten
client.beta.memoryStores.memoryVersions.list(memoryStoreID, params?, options?): PageCursor<BetaManagedAgentsMemoryVersion>
GET/v1/memory_stores/{memory_store_id}/memory_versions
Memory-Version abrufen
client.beta.memoryStores.memoryVersions.retrieve(memoryVersionID, params, options?): BetaManagedAgentsMemoryVersion
GET/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}
Memory-Version schwärzen
client.beta.memoryStores.memoryVersions.redact(memoryVersionID, params, options?): BetaManagedAgentsMemoryVersion
POST/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}/redact

BetaDateien

Datei hochladen
client.beta.files.upload(params, options?): BetaFileMetadata
POST/v1/files
Dateien auflisten
client.beta.files.list(params?, options?): PageCursor<BetaFileMetadata>
GET/v1/files
Datei herunterladen
client.beta.files.download(fileID, params?, options?): Response
GET/v1/files/{file_id}/content
Dateimetadaten abrufen
client.beta.files.retrieveMetadata(fileID, params?, options?): BetaFileMetadata
GET/v1/files/{file_id}
Datei löschen
client.beta.files.delete(fileID, params?, options?): BetaDeletedFile
DELETE/v1/files/{file_id}

BetaSkills

Skill erstellen
client.beta.skills.create(params, options?): BetaSkill
POST/v1/skills
Skills auflisten
client.beta.skills.list(params?, options?): PageCursor<BetaSkill>
GET/v1/skills
Skill abrufen
client.beta.skills.retrieve(skillID, params?, options?): BetaSkill
GET/v1/skills/{skill_id}
Skill löschen
client.beta.skills.delete(skillID, params?, options?): BetaDeletedSkill
DELETE/v1/skills/{skill_id}

BetaSkillsVersionen

Skill-Version erstellen
client.beta.skills.versions.create(skillID, params, options?): BetaSkillVersion
POST/v1/skills/{skill_id}/versions
Skill-Versionen auflisten
client.beta.skills.versions.list(skillID, params?, options?): PageCursor<BetaSkillVersion>
GET/v1/skills/{skill_id}/versions
Inhalt einer Skill-Version herunterladen
client.beta.skills.versions.download(version, params, options?): Response
GET/v1/skills/{skill_id}/versions/{version}/content

Lädt den Inhalt einer Skill-Version als ZIP-Archiv herunter.

Skill-Version abrufen
client.beta.skills.versions.retrieve(version, params, options?): BetaSkillVersion
GET/v1/skills/{skill_id}/versions/{version}
Skill-Version löschen
client.beta.skills.versions.delete(version, params, options?): BetaDeletedSkillVersion
DELETE/v1/skills/{skill_id}/versions/{version}

BetaBenutzerprofile

Benutzerprofil erstellen
client.beta.userProfiles.create(params, options?): BetaUserProfile
POST/v1/user_profiles
Benutzerprofile auflisten
client.beta.userProfiles.list(params?, options?): PageCursor<BetaUserProfile>
GET/v1/user_profiles
Benutzerprofil abrufen
client.beta.userProfiles.retrieve(userProfileID, params?, options?): BetaUserProfile
GET/v1/user_profiles/{user_profile_id}
Benutzerprofil aktualisieren
client.beta.userProfiles.update(userProfileID, params, options?): BetaUserProfile
POST/v1/user_profiles/{user_profile_id}
Enrollment-URL erstellen
client.beta.userProfiles.createEnrollmentURL(userProfileID, params?, options?): BetaUserProfileEnrollmentURL
POST/v1/user_profiles/{user_profile_id}/enrollment_url

BetaDreams

Dream erstellen
client.beta.dreams.create(params, options?): BetaDream
POST/v1/dreams

Startet einen asynchronen Job, der vergangene Sessions nutzt, um eine neu organisierte Version eines Memory Stores zu erzeugen, und gibt den Dream zurück, den du für das Ergebnis abfragen kannst.

Dreams auflisten
client.beta.dreams.list(params?, options?): PageCursor<BetaDream>
GET/v1/dreams

Listet die Dreams im Workspace auf, die neuesten zuerst.

Dream abrufen
client.beta.dreams.retrieve(dreamID, params?, options?): BetaDream
GET/v1/dreams/{dream_id}

Ruft einen Dream anhand seiner ID ab, um seinen Status, den Ausgabe-Memory-Store und die Token-Nutzung zu prüfen.

Dream abbrechen
client.beta.dreams.cancel(dreamID, params?, options?): BetaDream
POST/v1/dreams/{dream_id}/cancel

Stoppt einen Dream mit dem Status pending oder running.

Dream archivieren
client.beta.dreams.archive(dreamID, params?, options?): BetaDream
POST/v1/dreams/{dream_id}/archive

Blendet einen Dream mit dem Status completed, failed oder canceled aus der Standardliste der Dreams aus.

BetaTunnel

Tunnel erstellen
client.beta.tunnels.create(params, options?): BetaTunnel
POST/v1/tunnels

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnel abrufen
client.beta.tunnels.retrieve(tunnelID, params?, options?): BetaTunnel
GET/v1/tunnels/{tunnel_id}

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnels auflisten
client.beta.tunnels.list(params?, options?): PageCursor<BetaTunnel>
GET/v1/tunnels

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnel archivieren
client.beta.tunnels.archive(tunnelID, params?, options?): BetaTunnel
POST/v1/tunnels/{tunnel_id}/archive

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnel-Token anzeigen
client.beta.tunnels.revealToken(tunnelID, params?, options?): BetaTunnelToken
POST/v1/tunnels/{tunnel_id}/reveal_token

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnel-Token rotieren
client.beta.tunnels.rotateToken(tunnelID, params, options?): BetaTunnelToken
POST/v1/tunnels/{tunnel_id}/rotate_token

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

BetaTunnelZertifikate

Tunnel-Zertifikat erstellen
client.beta.tunnels.certificates.create(tunnelID, params, options?): BetaTunnelCertificate
POST/v1/tunnels/{tunnel_id}/certificates

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnel-Zertifikat abrufen
client.beta.tunnels.certificates.retrieve(certificateID, params, options?): BetaTunnelCertificate
GET/v1/tunnels/{tunnel_id}/certificates/{certificate_id}

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnel-Zertifikate auflisten
client.beta.tunnels.certificates.list(tunnelID, params?, options?): PageCursor<BetaTunnelCertificate>
GET/v1/tunnels/{tunnel_id}/certificates

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

Tunnel-Zertifikat archivieren
client.beta.tunnels.certificates.archive(certificateID, params, options?): BetaTunnelCertificate
POST/v1/tunnels/{tunnel_id}/certificates/{certificate_id}/archive

Die Tunnels API befindet sich in der "Research Preview" (Forschungsvorschau). Sie erfordert den Header anthropic-beta: mcp-tunnels-2026-06-22 und kann sich ohne Abkündigungsfrist ändern. Sie ersetzt die Admin-API-Endpunkte unter /v1/organizations/tunnels, die während eines Migrationszeitraums weiterhin verfügbar bleiben.

BetaOrganisation

Aktuelle Organisation abrufen
client.beta.organization.retrieve(options?): BetaOrganization
GET/v1/organizations/me

Ruft Informationen über die Organisation ab, die mit dem authentifizierten API-Key verknüpft ist.

BetaOrganisationAPI-Keys

API-Keys auflisten
client.beta.organization.apiKeys.list(query?, options?): Page<BetaAPIKey>
GET/v1/organizations/api_keys
API-Key abrufen (Admin API)
client.beta.organization.apiKeys.retrieve(apiKeyID, options?): BetaAPIKey
GET/v1/organizations/api_keys/{api_key_id}

Ruft Informationen über einen einzelnen API-Key in deiner Organisation ab, der anhand seiner ID gesucht wird. Dieser Admin-API-Endpunkt erfordert einen Admin-API-Key, ist für die programmatische Key-Verwaltung vorgesehen und gibt niemals den geheimen Wert des Keys zurück. Um deine eigenen API-Keys anzuzeigen oder zu erstellen, gehe in der Claude Console zu API-Keys.

API-Key aktualisieren
client.beta.organization.apiKeys.update(apiKeyID, body, options?): BetaAPIKey
POST/v1/organizations/api_keys/{api_key_id}

BetaOrganisationExterne Keys

Externen Key erstellen
client.beta.organization.externalKeys.create(body, options?): BetaExternalKey
POST/v1/organizations/external_keys

Erstellt eine externe Key-Konfiguration, die der Organisation des Aufrufers gehört.

Externe Keys auflisten
client.beta.organization.externalKeys.list(query?, options?): PageCursor<BetaExternalKey>
GET/v1/organizations/external_keys

Listet externe Key-Konfigurationen in der Organisation des Aufrufers auf.

Externen Key abrufen
client.beta.organization.externalKeys.retrieve(externalKeyID, options?): BetaExternalKey
GET/v1/organizations/external_keys/{external_key_id}

Ruft eine einzelne externe Key-Konfiguration in der Organisation des Aufrufers anhand der ID ab.

Externen Key aktualisieren
client.beta.organization.externalKeys.update(externalKeyID, body, options?): BetaExternalKey
POST/v1/organizations/external_keys/{external_key_id}

Aktualisiert eine externe Key-Konfiguration teilweise. Ausgelassene Felder bleiben unverändert.

Externen Key löschen
client.beta.organization.externalKeys.delete(externalKeyID, options?): ExternalKeyDeleteResponse
DELETE/v1/organizations/external_keys/{external_key_id}

Löscht eine externe Key-Konfiguration.

Externen Key validieren
client.beta.organization.externalKeys.validate(externalKeyID, options?): ExternalKeyValidateResponse
POST/v1/organizations/external_keys/{external_key_id}/validate

Validiert eine externe Key-Konfiguration gegen das KMS des Kunden.

BetaOrganisationFöderationIssuer

Federation-Issuer erstellen
client.beta.organization.federation.issuers.create(params, options?): BetaFederationIssuer
POST/v1/organizations/federation_issuers

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Issuer auflisten
client.beta.organization.federation.issuers.list(params?, options?): PageCursor<BetaFederationIssuer>
GET/v1/organizations/federation_issuers

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Issuer abrufen
client.beta.organization.federation.issuers.retrieve(federationIssuerID, params?, options?): BetaFederationIssuer
GET/v1/organizations/federation_issuers/{federation_issuer_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Issuer aktualisieren
client.beta.organization.federation.issuers.update(federationIssuerID, params, options?): BetaFederationIssuer
POST/v1/organizations/federation_issuers/{federation_issuer_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Issuer archivieren
client.beta.organization.federation.issuers.archive(federationIssuerID, params?, options?): BetaFederationIssuer
POST/v1/organizations/federation_issuers/{federation_issuer_id}/archive

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

BetaOrganisationFöderationRegeln

Federation-Regel erstellen
client.beta.organization.federation.rules.create(params, options?): BetaFederationRule
POST/v1/organizations/federation_rules

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Regeln auflisten
client.beta.organization.federation.rules.list(params?, options?): PageCursor<BetaFederationRule>
GET/v1/organizations/federation_rules

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Regel abrufen
client.beta.organization.federation.rules.retrieve(federationRuleID, params?, options?): BetaFederationRule
GET/v1/organizations/federation_rules/{federation_rule_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Regel aktualisieren
client.beta.organization.federation.rules.update(federationRuleID, params, options?): BetaFederationRule
POST/v1/organizations/federation_rules/{federation_rule_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Federation-Regel archivieren
client.beta.organization.federation.rules.archive(federationRuleID, params?, options?): BetaFederationRule
POST/v1/organizations/federation_rules/{federation_rule_id}/archive

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

BetaOrganisationFöderationRegelnWorkspaces

Workspace zu Federation-Regel hinzufügen
client.beta.organization.federation.rules.workspaces.add(federationRuleID, params, options?): BetaFederationRuleWorkspace
POST/v1/organizations/federation_rules/{federation_rule_id}/workspaces

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Workspaces einer Federation-Regel auflisten
client.beta.organization.federation.rules.workspaces.list(federationRuleID, params?, options?): PageCursor<BetaFederationRuleWorkspace>
GET/v1/organizations/federation_rules/{federation_rule_id}/workspaces

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Workspace aus Federation-Regel entfernen
client.beta.organization.federation.rules.workspaces.remove(workspaceID, params, options?): WorkspaceRemoveResponse
DELETE/v1/organizations/federation_rules/{federation_rule_id}/workspaces/{workspace_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

BetaOrganisationEinladungen

Einladung erstellen
client.beta.organization.invites.create(body, options?): BetaOrganizationInvite
POST/v1/organizations/invites

Lädt einen Benutzer per E-Mail ein, der Organisation beizutreten.

Einladungen auflisten
client.beta.organization.invites.list(query?, options?): Page<BetaOrganizationInvite>
GET/v1/organizations/invites

Listet die Einladungen der Organisation auf.

Einladung abrufen
client.beta.organization.invites.retrieve(inviteID, options?): BetaOrganizationInvite
GET/v1/organizations/invites/{invite_id}

Ruft eine Einladung anhand der ID ab.

Einladung löschen
client.beta.organization.invites.delete(inviteID, options?): InviteDeleteResponse
DELETE/v1/organizations/invites/{invite_id}

Löscht eine ausstehende Einladung.

BetaOrganisationService-Accounts

Service-Account erstellen
client.beta.organization.serviceAccounts.create(params, options?): BetaServiceAccount
POST/v1/organizations/service_accounts

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Accounts auflisten
client.beta.organization.serviceAccounts.list(params?, options?): PageCursor<BetaServiceAccount>
GET/v1/organizations/service_accounts

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Account abrufen
client.beta.organization.serviceAccounts.retrieve(serviceAccountID, params?, options?): BetaServiceAccount
GET/v1/organizations/service_accounts/{service_account_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Account aktualisieren
client.beta.organization.serviceAccounts.update(serviceAccountID, params, options?): BetaServiceAccount
POST/v1/organizations/service_accounts/{service_account_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Account archivieren
client.beta.organization.serviceAccounts.archive(serviceAccountID, params?, options?): BetaServiceAccount
POST/v1/organizations/service_accounts/{service_account_id}/archive

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

BetaOrganisationService-AccountsWorkspaces

Workspace zu Service-Account hinzufügen
client.beta.organization.serviceAccounts.workspaces.add(serviceAccountID, params, options?): BetaServiceAccountWorkspaceMember
POST/v1/organizations/service_accounts/{service_account_id}/workspaces

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Workspaces eines Service-Accounts auflisten
client.beta.organization.serviceAccounts.workspaces.list(serviceAccountID, params?, options?): PageCursor<BetaServiceAccountWorkspaceMember>
GET/v1/organizations/service_accounts/{service_account_id}/workspaces

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Workspace aus Service-Account entfernen
client.beta.organization.serviceAccounts.workspaces.remove(workspaceID, params, options?): WorkspaceRemoveResponse
DELETE/v1/organizations/service_accounts/{service_account_id}/workspaces/{workspace_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

BetaOrganisationBenutzer

Benutzer auflisten
client.beta.organization.users.list(query?, options?): Page<BetaOrganizationUser>
GET/v1/organizations/users

Listet die Mitglieder der Organisation auf.

Benutzer abrufen
client.beta.organization.users.retrieve(userID, options?): BetaOrganizationUser
GET/v1/organizations/users/{user_id}

Ruft ein Mitglied der Organisation anhand der Benutzer-ID ab.

Benutzer aktualisieren
client.beta.organization.users.update(userID, body, options?): BetaOrganizationUser
POST/v1/organizations/users/{user_id}

Aktualisiert die Organisationsrolle eines Mitglieds.

Benutzer entfernen
client.beta.organization.users.remove(userID, options?): UserRemoveResponse
DELETE/v1/organizations/users/{user_id}

Entfernt ein Mitglied aus der Organisation.

BetaOrganisationWorkspaces

Workspaces auflisten
client.beta.organization.workspaces.list(query?, options?): Page<BetaWorkspace>
GET/v1/organizations/workspaces
Workspace erstellen
client.beta.organization.workspaces.create(params, options?): BetaWorkspace
POST/v1/organizations/workspaces
Workspace abrufen
client.beta.organization.workspaces.retrieve(workspaceID, options?): BetaWorkspace
GET/v1/organizations/workspaces/{workspace_id}
Workspace aktualisieren
client.beta.organization.workspaces.update(workspaceID, body, options?): BetaWorkspace
POST/v1/organizations/workspaces/{workspace_id}
Workspace archivieren
client.beta.organization.workspaces.archive(workspaceID, options?): BetaWorkspace
POST/v1/organizations/workspaces/{workspace_id}/archive

BetaOrganisationWorkspacesRatenlimits

Workspace-Ratenlimits auflisten
client.beta.organization.workspaces.rateLimits.list(workspaceID, query?, options?): PageCursor<BetaWorkspaceRateLimit>
GET/v1/organizations/workspaces/{workspace_id}/rate_limits

Listet die Ratenlimits eines Workspace auf.

BetaOrganisationWorkspacesMitglieder

Workspace-Mitglieder auflisten
client.beta.organization.workspaces.members.list(workspaceID, query?, options?): Page<BetaWorkspaceMember>
GET/v1/organizations/workspaces/{workspace_id}/members
Workspace-Mitglied erstellen
client.beta.organization.workspaces.members.add(workspaceID, body, options?): BetaWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/members
Workspace-Mitglied abrufen
client.beta.organization.workspaces.members.retrieve(userID, params, options?): BetaWorkspaceMember
GET/v1/organizations/workspaces/{workspace_id}/members/{user_id}
Workspace-Mitglied aktualisieren
client.beta.organization.workspaces.members.update(userID, params, options?): BetaWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/members/{user_id}
Workspace-Mitglied löschen
client.beta.organization.workspaces.members.remove(userID, params, options?): MemberRemoveResponse
DELETE/v1/organizations/workspaces/{workspace_id}/members/{user_id}

BetaOrganisationWorkspacesService-Accounts

Service-Account-Mitglieder eines Workspace auflisten
client.beta.organization.workspaces.serviceAccounts.list(workspaceID, params?, options?): PageCursor<BetaServiceAccountWorkspaceMember>
GET/v1/organizations/workspaces/{workspace_id}/service_accounts

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Account-Mitglied eines Workspace erstellen
client.beta.organization.workspaces.serviceAccounts.add(workspaceID, params, options?): BetaServiceAccountWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/service_accounts

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Account-Mitglied eines Workspace abrufen
client.beta.organization.workspaces.serviceAccounts.retrieve(serviceAccountID, params, options?): BetaServiceAccountWorkspaceMember
GET/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Account-Mitglied eines Workspace aktualisieren
client.beta.organization.workspaces.serviceAccounts.update(serviceAccountID, params, options?): BetaServiceAccountWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}

Erfordert ein OAuth-Zugriffstoken mit dem Scope org:admin, über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

Service-Account-Mitglied eines Workspace löschen
client.beta.organization.workspaces.serviceAccounts.remove(serviceAccountID, params, options?): ServiceAccountRemoveResponse
DELETE/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}

Erfordert ein OAuth-Access-Token mit dem Scope org:admin, erhältlich über ant auth login --scope org:admin oder eine Workload-Identity-Federation-Regel; Admin-API-Keys werden nicht akzeptiert. Siehe WIF mit der Admin API verwalten.

BetaOrganisationRatenlimits

Ratenlimits der Organisation auflisten
client.beta.organization.rateLimits.list(query?, options?): PageCursor<BetaOrganizationRateLimit>
GET/v1/organizations/rate_limits

Listet die Ratenlimits der Messages API für deine Organisation auf.

BetaOrganisationCompliance-Einstellungen

Compliance-Einstellungen abrufen
client.beta.organization.complianceSettings.retrieve(options?): BetaComplianceSettings
GET/v1/organizations/compliance_settings

Ruft die Compliance Settings deiner Organisation ab.

Compliance-Einstellungen aktualisieren
client.beta.organization.complianceSettings.update(body, options?): BetaComplianceSettings
POST/v1/organizations/compliance_settings

Aktualisiert die Compliance Settings deiner Organisation.

BetaOrganisationAnalysenZusammenfassungen

Aktivitätszusammenfassungen abrufen
client.beta.organization.analytics.summaries.list(query, options?): PageCursor<BetaAnalyticsSingleDayActivitySummary>
GET/v1/organizations/analytics/summaries

Ruft organisationsweite Aktivitätszusammenfassungen für einen Datumsbereich ab.

BetaOrganisationAnalysenBenutzer

Benutzeraktivität auflisten
client.beta.organization.analytics.users.list(query?, options?): PageCursor<BetaAnalyticsUserActivity>
GET/v1/organizations/analytics/users

Ruft die Aktivität pro Benutzer für einen bestimmten Tag ab, mit Cursor-basierter Paginierung.

BetaOrganisationAnalysenAppsChatProjekte

Chat-Projektnutzung abrufen
client.beta.organization.analytics.apps.chat.projects.list(query?, options?): PageCursor<BetaAnalyticsProjectActivity>
GET/v1/organizations/analytics/apps/chat/projects

Ruft die Aktivität pro Projekt für einen bestimmten Tag ab, mit cursorbasierter Paginierung.

BetaOrganisationAnalysenKonnektoren

Konnektor-Nutzung abrufen
client.beta.organization.analytics.connectors.list(query?, options?): PageCursor<BetaAnalyticsConnectorActivity>
GET/v1/organizations/analytics/connectors

Ruft die Nutzung pro Konnektor für einen bestimmten Tag ab, mit Cursor-basierter Paginierung.

BetaOrganisationAnalysenPlugins

Plugin-Nutzung abrufen
client.beta.organization.analytics.plugins.list(query?, options?): PageCursor<BetaAnalyticsPluginActivity>
GET/v1/organizations/analytics/plugins

Ruft die Installations- und Aufrufnutzung pro Plugin für einen bestimmten Tag ab, mit Paginierung.

BetaOrganisationAnalysenSkills

Skill-Nutzung abrufen
client.beta.organization.analytics.skills.list(query?, options?): PageCursor<BetaAnalyticsSkillActivity>
GET/v1/organizations/analytics/skills

Ruft die Nutzung pro Skill für einen bestimmten Tag ab, mit Cursor-basierter Paginierung.

BetaOrganisationAnalysenArtifacts

Artifact-Aktivität abrufen
client.beta.organization.analytics.artifacts.list(query, options?): PageCursor<BetaAnalyticsArtifactActivity>
GET/v1/organizations/analytics/artifacts

Ruft die Aktivität zur Artifact-Erstellung für einen bestimmten Tag ab, aufgeschlüsselt nach MIME-Typ.

BetaOrganisationAnalysenNutzungsbericht

Token-Nutzung im Zeitverlauf abrufen
client.beta.organization.analytics.usageReport.list(query, options?): PageCursor<BetaAnalyticsUsageReportTimeBucket>
GET/v1/organizations/analytics/usage_report

Ruft die Token-Nutzung im Zeitverlauf über einen Datumsbereich ab.

BetaOrganisationAnalysenNutzungsbericht pro Benutzer

Token-Nutzung pro Benutzer abrufen
client.beta.organization.analytics.userUsageReport.list(query, options?): PageCursor<BetaAnalyticsUsageUsersItem>
GET/v1/organizations/analytics/user_usage_report

Ruft die Token-Nutzung pro Benutzer über einen Datumsbereich ab.

BetaOrganisationAnalysenKostenbericht

Kosten im Zeitverlauf abrufen
client.beta.organization.analytics.costReport.list(query, options?): PageCursor<BetaAnalyticsCostReportTimeBucket>
GET/v1/organizations/analytics/cost_report

Ruft die Kosten in USD im Zeitverlauf über einen Datumsbereich ab.

BetaOrganisationAnalysenKostenbericht pro Benutzer

Kosten pro Benutzer abrufen
client.beta.organization.analytics.userCostReport.list(query, options?): PageCursor<BetaAnalyticsCostUsersItem>
GET/v1/organizations/analytics/user_cost_report

Ruft die Kosten pro Benutzer in USD über einen Datumsbereich ab.

BetaOrganisationAusgabenlimits

Ausgabenlimit festlegen
client.beta.organization.spendLimits.set(params, options?): BetaSpendLimit
POST/v1/organizations/spend_limits

Legt ein Ausgabenlimit fest.

Ausgabenlimit abrufen
client.beta.organization.spendLimits.retrieve(spendLimitID, options?): BetaSpendLimit
GET/v1/organizations/spend_limits/{spend_limit_id}

Ruft ein Ausgabenlimit anhand seiner ID ab.

Ausgabenlimit löschen
client.beta.organization.spendLimits.delete(spendLimitID, options?): SpendLimitDeleteResponse
DELETE/v1/organizations/spend_limits/{spend_limit_id}

Löscht ein Ausgabenlimit.

Ausgabenlimits auflisten
client.beta.organization.spendLimits.list(params?, options?): PageCursor<BetaSpendLimit>
GET/v1/organizations/spend_limits

Listet die Ausgabenlimits der Organisation auf.

BetaOrganisationAusgabenlimitsEffektiv

Effektive Ausgabenlimits auflisten
client.beta.organization.spendLimits.effective.list(query?, options?): PageCursor<BetaSpendSummary>
GET/v1/organizations/spend_limits/effective

Listet für jedes Mitglied das effektive Ausgabenlimit und die bisherigen Ausgaben im Zeitraum auf.

BetaOrganisationAusgabenlimitsErhöhungsanfragen

Anfragen zur Erhöhung des Ausgabenlimits auflisten
client.beta.organization.spendLimits.increaseRequests.list(query?, options?): PageCursor<BetaSpendLimitIncreaseRequest>
GET/v1/organizations/spend_limit_increase_requests

Listet Anfragen zur Erhöhung des Ausgabenlimits auf, neueste zuerst.

Anfrage zur Erhöhung des Ausgabenlimits abrufen
client.beta.organization.spendLimits.increaseRequests.retrieve(spendLimitIncreaseRequestID, options?): BetaSpendLimitIncreaseRequest
GET/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}

Ruft eine Anfrage zur Erhöhung des Ausgabenlimits ab.

Anfrage zur Erhöhung des Ausgabenlimits genehmigen
client.beta.organization.spendLimits.increaseRequests.approve(spendLimitIncreaseRequestID, body, options?): IncreaseRequestApproveResponse
POST/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}/approve

Genehmigt eine ausstehende Anfrage zur Erhöhung des Ausgabenlimits.

Anfrage zur Erhöhung des Ausgabenlimits ablehnen
client.beta.organization.spendLimits.increaseRequests.deny(spendLimitIncreaseRequestID, body, options?): BetaSpendLimitIncreaseRequest
POST/v1/organizations/spend_limit_increase_requests/{spend_limit_increase_request_id}/deny

Lehnt eine ausstehende Anfrage zur Erhöhung des Ausgabenlimits ab.

BetaOrganisationRBAC-Gruppen

RBAC-Gruppe erstellen
client.beta.organization.rbacGroups.create(body, options?): BetaRBACGroup
POST/v1/organizations/rbac_groups

Erstellt eine RBAC-Gruppe im Claude Enterprise-Tenant. Über die API erstellte Gruppen haben den Quelltyp "direct".

RBAC-Gruppen auflisten
client.beta.organization.rbacGroups.list(query?, options?): PageCursor<BetaRBACGroup>
GET/v1/organizations/rbac_groups

Listet RBAC-Gruppen im Claude Enterprise-Tenant auf.

RBAC-Gruppe abrufen
client.beta.organization.rbacGroups.retrieve(rbacGroupID, options?): BetaRBACGroup
GET/v1/organizations/rbac_groups/{rbac_group_id}

Ruft eine RBAC-Gruppe anhand ihrer ID ab.

RBAC-Gruppe aktualisieren
client.beta.organization.rbacGroups.update(rbacGroupID, body, options?): BetaRBACGroup
POST/v1/organizations/rbac_groups/{rbac_group_id}

Aktualisiert den Namen einer RBAC-Gruppe. Von einem Identitätsanbieter bereitgestellte Gruppen (Quelltyp "scim") können nicht über die API geändert werden, solange eine Organisation im Tenant SCIM-Provisionierung verwendet.

RBAC-Gruppe löschen
client.beta.organization.rbacGroups.delete(rbacGroupID, options?): RBACGroupDeleteResponse
DELETE/v1/organizations/rbac_groups/{rbac_group_id}

Löscht eine RBAC-Gruppe. Von einem Identitätsanbieter bereitgestellte Gruppen (Quelltyp "scim") können nicht über die API gelöscht werden, solange eine Organisation im Tenant SCIM-Provisionierung verwendet.

BetaOrganisationRBAC-GruppenMitglieder

Mitglieder einer RBAC-Gruppe auflisten
client.beta.organization.rbacGroups.members.list(rbacGroupID, query?, options?): PageCursor<BetaRBACGroupMember>
GET/v1/organizations/rbac_groups/{rbac_group_id}/members

Listet die Mitglieder einer RBAC-Gruppe auf.

Mitglied zu RBAC-Gruppe hinzufügen
client.beta.organization.rbacGroups.members.add(rbacGroupID, body, options?): BetaRBACGroupMember
POST/v1/organizations/rbac_groups/{rbac_group_id}/members

Fügt einen Benutzer zu einer RBAC-Gruppe hinzu. Die Mitgliedschaft in Gruppen, die von einem Identitätsanbieter bereitgestellt werden (Quelltyp "scim"), kann nicht über die API geändert werden, solange eine Organisation im Tenant SCIM-Provisioning verwendet.

Mitglied aus RBAC-Gruppe entfernen
client.beta.organization.rbacGroups.members.remove(userID, params, options?): MemberRemoveResponse
DELETE/v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}

Entfernt einen Benutzer aus einer RBAC-Gruppe. Die Mitgliedschaft in Gruppen, die von einem Identitätsanbieter bereitgestellt werden (Quelltyp "scim"), kann nicht über die API geändert werden, solange eine Organisation im Tenant SCIM-Provisioning verwendet.

BetaOrganisationRBAC-Rollen

RBAC-Rollen auflisten
client.beta.organization.rbacRoles.list(query?, options?): PageCursor<BetaRBACRole>
GET/v1/organizations/rbac_roles

Listet RBAC-Rollen in der Organisation auf.

RBAC-Rolle abrufen
client.beta.organization.rbacRoles.retrieve(rbacRoleID, options?): BetaRBACRole
GET/v1/organizations/rbac_roles/{rbac_role_id}

Ruft eine RBAC-Rolle anhand ihrer ID ab.

BetaOrganisationRBAC-RollenBerechtigungen

Berechtigungen einer RBAC-Rolle auflisten
client.beta.organization.rbacRoles.permissions.list(rbacRoleID, query?, options?): PageCursor<BetaRBACRolePermission>
GET/v1/organizations/rbac_roles/{rbac_role_id}/permissions

Listet die Berechtigungen auf, die eine RBAC-Rolle gewährt.

BetaOrganisationPlugins

Plugin erstellen
client.beta.organization.plugins.create(params, options?): BetaPlugin
POST/v1/organizations/plugins

Erstellt ein Plugin im Besitz der Organisation und seine erste Version, indem die Dateien der Version hochgeladen werden.

Plugin abrufen
client.beta.organization.plugins.retrieve(pluginID, params?, options?): BetaPlugin
GET/v1/organizations/plugins/{plugin_id}

Ruft ein Plugin anhand seiner ID ab.

Plugin aktualisieren
client.beta.organization.plugins.update(pluginID, params, options?): BetaPlugin
POST/v1/organizations/plugins/{plugin_id}

Ändere, welche gespeicherte Version eines organisationseigenen Plugins an Mitglieder ausgeliefert wird, zum Beispiel um zu einer früheren zurückzukehren. Dadurch wird die ausgelieferte Version fixiert: Spätere Uploads werden gespeichert, ändern aber nicht mehr, was ausgeliefert wird, und die Fixierung kann derzeit nicht rückgängig gemacht werden, weder hier noch in claude.ai.

Plugins auflisten
client.beta.organization.plugins.list(params?, options?): PageCursor<BetaPlugin>
GET/v1/organizations/plugins

Listet die unter der Organisation erstellten Plugins auf, die neuesten zuerst: diejenigen in den eigenen Plugin-Marketplaces der Organisation und diejenigen in den persönlichen Plugin-Marketplaces der Mitglieder.

Plugin löschen
client.beta.organization.plugins.delete(pluginID, params?, options?): BetaDeletedPlugin
DELETE/v1/organizations/plugins/{plugin_id}

Löscht ein Plugin und jede seiner Versionen dauerhaft, genau so, als würde ein Administrator es in claude.ai löschen. Das Plugin kann der Organisation oder einem Mitglied gehören, auch einem Mitglied, das die Organisation inzwischen verlassen hat.

BetaOrganisationPluginsVersionen

Plugin-Version erstellen
client.beta.organization.plugins.versions.create(pluginID, params, options?): BetaPluginVersion
POST/v1/organizations/plugins/{plugin_id}/versions

Fügt einem organisationseigenen Plugin eine Version hinzu, indem die Dateien der neuen Version hochgeladen werden; sie wird zur an Mitglieder ausgelieferten Version, sofern die ausgelieferte Version des Plugins nicht fixiert wurde.

Plugin-Versionen auflisten
client.beta.organization.plugins.versions.list(pluginID, params?, options?): PageCursor<BetaPluginVersion>
GET/v1/organizations/plugins/{plugin_id}/versions

Listet die Versionen eines Plugins auf, die neuesten zuerst.

Plugin-Version abrufen
client.beta.organization.plugins.versions.retrieve(version, params, options?): BetaPluginVersion
GET/v1/organizations/plugins/{plugin_id}/versions/{version}

Ruft eine Version eines Plugins anhand ihrer ID oder die neueste Version des Plugins ab.

Archiv einer Plugin-Version herunterladen
client.beta.organization.plugins.versions.download(version, params, options?): Response
GET/v1/organizations/plugins/{plugin_id}/versions/{version}/content

Lädt das .zip-Archiv einer Version genau so herunter, wie es gespeichert ist. Jeder Download eines Plugins aus dem persönlichen Plugin-Marketplace eines Mitglieds wird im Aktivitäts-Feed der Compliance API protokolliert.

BetaOrganisationPluginsInstallationseinstellungen

Plugin-Installationseinstellungen auflisten
client.beta.organization.plugins.installationSettings.list(pluginID, params?, options?): PageCursor<BetaPluginInstallationSetting>
GET/v1/organizations/plugins/{plugin_id}/installation_settings

Listet die Installationseinstellungen eines organisationseigenen Plugins auf, die angeben, für welche Mitglieder es bestimmt ist, die zuletzt erstellten zuerst.

Plugin-Installationseinstellung festlegen
client.beta.organization.plugins.installationSettings.set(target, params, options?): BetaPluginInstallationSetting
POST/v1/organizations/plugins/{plugin_id}/installation_settings/{target}

Legt die Installationseinstellung eines organisationseigenen Plugins für die gesamte Organisation oder für eine RBAC-Gruppe fest oder ändert sie.

Plugin-Installationseinstellung entfernen
client.beta.organization.plugins.installationSettings.remove(target, params, options?): BetaDeletedPluginInstallationSetting
DELETE/v1/organizations/plugins/{plugin_id}/installation_settings/{target}

Entfernt die eigene Installationseinstellung eines organisationseigenen Plugins für die gesamte Organisation oder für eine RBAC-Gruppe.

BetaOrganisationPluginsFreigaben

Plugin-Freigaben auflisten
client.beta.organization.plugins.shares.list(pluginID, params?, options?): PageCursor<BetaPluginShare>
GET/v1/organizations/plugins/{plugin_id}/shares

Listet die Freigaben auf, die der Eigentümer eines mitgliedseigenen Plugins erteilt hat – für jedes Mitglied der Organisation, für eine RBAC-Gruppe oder für ein einzelnes Mitglied –, die zuletzt erteilten zuerst.

BetaOrganisationPlugin-Marketplaces

Plugin-Marketplaces auflisten
client.beta.organization.pluginMarketplaces.list(params?, options?): PageCursor<BetaPluginMarketplace>
GET/v1/organizations/plugin_marketplaces

Listet die Plugin-Marketplaces auf, in denen sich Plugins befinden, die neuesten zuerst: die eigenen der Organisation und die persönlichen ihrer Mitglieder.

Plugin-Marketplace abrufen
client.beta.organization.pluginMarketplaces.retrieve(marketplaceID, params?, options?): BetaPluginMarketplace
GET/v1/organizations/plugin_marketplaces/{marketplace_id}

Ruft einen Plugin-Marketplace anhand seiner ID ab.

Plugin-Marketplace aktualisieren
client.beta.organization.pluginMarketplaces.update(marketplaceID, params, options?): BetaPluginMarketplace
POST/v1/organizations/plugin_marketplaces/{marketplace_id}

Legt die Standard-Installationseinstellung eines der eigenen Plugin-Marketplaces der Organisation fest. Jedes darin enthaltene Plugin ohne eigene Einstellung erhält diesen Standard als seine organisationsweite Einstellung, einschließlich später hinzugefügter Plugins.

Plugin-Marketplace-Repository validieren
client.beta.organization.pluginMarketplaces.validateRepository(params, options?): BetaPluginMarketplaceValidationReport
POST/v1/organizations/plugin_marketplaces/validate_repository

Prüft, ob ein Plugin-Marketplace in einem öffentlichen GitHub-Repository in claude.ai synchronisiert werden würde, ohne ihn zu verbinden oder zu speichern.

Plugin-Marketplace-Archiv validieren
client.beta.organization.pluginMarketplaces.validateArchive(params, options?): BetaPluginMarketplaceValidationReport
POST/v1/organizations/plugin_marketplaces/validate_archive

Prüft, ob ein Plugin-Marketplace, hochgeladen als .zip-Datei des Marketplace-Verzeichnisses, in claude.ai synchronisiert werden würde, ohne ihn zu verbinden oder zu speichern.