Claude Platform Docs

Beta

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

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

BetaModels

List Models
client.beta.models.list(ModelListParamsparams?, RequestOptionsoptions?): Page<BetaModelInfo>
GET/v1/models
Get a Model
client.beta.models.retrieve(stringmodelID, ModelRetrieveParamsparams?, RequestOptionsoptions?): BetaModelInfo
GET/v1/models/{model_id}

BetaMessages

Create a Message
client.beta.messages.create(MessageCreateParamsparams, RequestOptionsoptions?): BetaMessage | Stream<BetaRawMessageStreamEvent>
POST/v1/messages
Count tokens in a Message
client.beta.messages.countTokens(MessageCountTokensParamsparams, RequestOptionsoptions?): BetaMessageTokensCount
POST/v1/messages/count_tokens

BetaMessagesBatches

Create a Message Batch
client.beta.messages.batches.create(BatchCreateParamsparams, RequestOptionsoptions?): BetaMessageBatch
POST/v1/messages/batches
Retrieve a Message Batch
client.beta.messages.batches.retrieve(stringmessageBatchID, BatchRetrieveParamsparams?, RequestOptionsoptions?): BetaMessageBatch
GET/v1/messages/batches/{message_batch_id}
List Message Batches
client.beta.messages.batches.list(BatchListParamsparams?, RequestOptionsoptions?): Page<BetaMessageBatch>
GET/v1/messages/batches
Cancel a Message Batch
client.beta.messages.batches.cancel(stringmessageBatchID, BatchCancelParamsparams?, RequestOptionsoptions?): BetaMessageBatch
POST/v1/messages/batches/{message_batch_id}/cancel
Delete a Message Batch
client.beta.messages.batches.delete(stringmessageBatchID, BatchDeleteParamsparams?, RequestOptionsoptions?): BetaDeletedMessageBatch
DELETE/v1/messages/batches/{message_batch_id}
Retrieve Message Batch results
client.beta.messages.batches.results(stringmessageBatchID, BatchResultsParamsparams?, RequestOptionsoptions?): BetaMessageBatchIndividualResponse | Stream<BetaMessageBatchIndividualResponse>
GET/v1/messages/batches/{message_batch_id}/results

BetaAgents

Create Agent
client.beta.agents.create(AgentCreateParamsparams, RequestOptionsoptions?): BetaManagedAgentsAgent
POST/v1/agents
List Agents
client.beta.agents.list(AgentListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsAgent>
GET/v1/agents
Get Agent
client.beta.agents.retrieve(stringagentID, AgentRetrieveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsAgent
GET/v1/agents/{agent_id}
Update Agent
client.beta.agents.update(stringagentID, AgentUpdateParamsparams, RequestOptionsoptions?): BetaManagedAgentsAgent
POST/v1/agents/{agent_id}
Archive Agent
client.beta.agents.archive(stringagentID, AgentArchiveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsAgent
POST/v1/agents/{agent_id}/archive

BetaAgentsVersions

List Agent Versions
client.beta.agents.versions.list(stringagentID, VersionListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsAgent>
GET/v1/agents/{agent_id}/versions

BetaEnvironments

Create Environment
client.beta.environments.create(EnvironmentCreateParamsparams, RequestOptionsoptions?): BetaEnvironment
POST/v1/environments
List Environments
client.beta.environments.list(EnvironmentListParamsparams?, RequestOptionsoptions?): PageCursor<BetaEnvironment>
GET/v1/environments
Get Environment
client.beta.environments.retrieve(stringenvironmentID, EnvironmentRetrieveParamsparams?, RequestOptionsoptions?): BetaEnvironment
GET/v1/environments/{environment_id}
Update Environment
client.beta.environments.update(stringenvironmentID, EnvironmentUpdateParamsparams, RequestOptionsoptions?): BetaEnvironment
POST/v1/environments/{environment_id}
Delete Environment
client.beta.environments.delete(stringenvironmentID, EnvironmentDeleteParamsparams?, RequestOptionsoptions?): BetaEnvironmentDeleteResponse
DELETE/v1/environments/{environment_id}
Archive Environment
client.beta.environments.archive(stringenvironmentID, EnvironmentArchiveParamsparams?, RequestOptionsoptions?): BetaEnvironment
POST/v1/environments/{environment_id}/archive

BetaEnvironmentsWork

Get Work Item
client.beta.environments.work.retrieve(stringworkID, WorkRetrieveParamsparams, RequestOptionsoptions?): BetaSelfHostedWork
GET/v1/environments/{environment_id}/work/{work_id}
Poll for Work
client.beta.environments.work.poll(stringenvironmentID, WorkPollParamsparams?, RequestOptionsoptions?): BetaSelfHostedWork | null
GET/v1/environments/{environment_id}/work/poll
Acknowledge Work
client.beta.environments.work.ack(stringworkID, WorkAckParamsparams, RequestOptionsoptions?): BetaSelfHostedWork
POST/v1/environments/{environment_id}/work/{work_id}/ack
Record Heartbeat
client.beta.environments.work.heartbeat(stringworkID, WorkHeartbeatParamsparams, RequestOptionsoptions?): BetaSelfHostedWorkHeartbeatResponse
POST/v1/environments/{environment_id}/work/{work_id}/heartbeat
Stop Work
client.beta.environments.work.stop(stringworkID, WorkStopParamsparams, RequestOptionsoptions?): BetaSelfHostedWork
POST/v1/environments/{environment_id}/work/{work_id}/stop
List Work Items
client.beta.environments.work.list(stringenvironmentID, WorkListParamsparams?, RequestOptionsoptions?): PageCursor<BetaSelfHostedWork>
GET/v1/environments/{environment_id}/work
Update Work Item
client.beta.environments.work.update(stringworkID, WorkUpdateParamsparams, RequestOptionsoptions?): BetaSelfHostedWork
POST/v1/environments/{environment_id}/work/{work_id}
Get Queue Statistics
client.beta.environments.work.stats(stringenvironmentID, WorkStatsParamsparams?, RequestOptionsoptions?): BetaSelfHostedWorkQueueStats
GET/v1/environments/{environment_id}/work/stats

BetaSessions

Create Session
client.beta.sessions.create(SessionCreateParamsparams, RequestOptionsoptions?): BetaManagedAgentsSession
POST/v1/sessions
List Sessions
client.beta.sessions.list(SessionListParamsparams?, RequestOptionsoptions?): BidirectionalPageCursor<BetaManagedAgentsSession>
GET/v1/sessions
Get Session
client.beta.sessions.retrieve(stringsessionID, SessionRetrieveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsSession
GET/v1/sessions/{session_id}
Update Session
client.beta.sessions.update(stringsessionID, SessionUpdateParamsparams, RequestOptionsoptions?): BetaManagedAgentsSession
POST/v1/sessions/{session_id}
Delete Session
client.beta.sessions.delete(stringsessionID, SessionDeleteParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeletedSession
DELETE/v1/sessions/{session_id}
Archive Session
client.beta.sessions.archive(stringsessionID, SessionArchiveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsSession
POST/v1/sessions/{session_id}/archive

BetaSessionsEvents

List Events
client.beta.sessions.events.list(stringsessionID, EventListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsSessionEvent>
GET/v1/sessions/{session_id}/events
Send Events
client.beta.sessions.events.send(stringsessionID, EventSendParamsparams, RequestOptionsoptions?): BetaManagedAgentsSendSessionEvents
POST/v1/sessions/{session_id}/events
Stream Events
client.beta.sessions.events.stream(stringsessionID, EventStreamParamsparams?, RequestOptionsoptions?): BetaManagedAgentsStreamSessionEvents | Stream<BetaManagedAgentsStreamSessionEvents>
GET/v1/sessions/{session_id}/events/stream

BetaSessionsResources

Add Session Resource
client.beta.sessions.resources.add(stringsessionID, ResourceAddParamsparams, RequestOptionsoptions?): BetaManagedAgentsFileResource
POST/v1/sessions/{session_id}/resources
List Session Resources
client.beta.sessions.resources.list(stringsessionID, ResourceListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsSessionResource>
GET/v1/sessions/{session_id}/resources
Get Session Resource
client.beta.sessions.resources.retrieve(stringresourceID, ResourceRetrieveParamsparams, RequestOptionsoptions?): ResourceRetrieveResponse
GET/v1/sessions/{session_id}/resources/{resource_id}
Update Session Resource
client.beta.sessions.resources.update(stringresourceID, ResourceUpdateParamsparams, RequestOptionsoptions?): ResourceUpdateResponse
POST/v1/sessions/{session_id}/resources/{resource_id}
Delete Session Resource
client.beta.sessions.resources.delete(stringresourceID, ResourceDeleteParamsparams, RequestOptionsoptions?): BetaManagedAgentsDeleteSessionResource
DELETE/v1/sessions/{session_id}/resources/{resource_id}

BetaSessionsThreads

List Session Threads
client.beta.sessions.threads.list(stringsessionID, ThreadListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsSessionThread>
GET/v1/sessions/{session_id}/threads
Get Session Thread
client.beta.sessions.threads.retrieve(stringthreadID, ThreadRetrieveParamsparams, RequestOptionsoptions?): BetaManagedAgentsSessionThread
GET/v1/sessions/{session_id}/threads/{thread_id}
Archive Session Thread
client.beta.sessions.threads.archive(stringthreadID, ThreadArchiveParamsparams, RequestOptionsoptions?): BetaManagedAgentsSessionThread
POST/v1/sessions/{session_id}/threads/{thread_id}/archive

BetaSessionsThreadsEvents

List Session Thread Events
client.beta.sessions.threads.events.list(stringthreadID, EventListParamsparams, RequestOptionsoptions?): PageCursor<BetaManagedAgentsSessionEvent>
GET/v1/sessions/{session_id}/threads/{thread_id}/events
Stream Session Thread Events
client.beta.sessions.threads.events.stream(stringthreadID, EventStreamParamsparams, RequestOptionsoptions?): BetaManagedAgentsStreamSessionThreadEvents | Stream<BetaManagedAgentsStreamSessionThreadEvents>
GET/v1/sessions/{session_id}/threads/{thread_id}/stream

BetaDeployments

Create Deployment
client.beta.deployments.create(DeploymentCreateParamsparams, RequestOptionsoptions?): BetaManagedAgentsDeployment
POST/v1/deployments
List Deployments
client.beta.deployments.list(DeploymentListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsDeployment>
GET/v1/deployments
Get Deployment
client.beta.deployments.retrieve(stringdeploymentID, DeploymentRetrieveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeployment
GET/v1/deployments/{deployment_id}
Update Deployment
client.beta.deployments.update(stringdeploymentID, DeploymentUpdateParamsparams, RequestOptionsoptions?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}
Archive Deployment
client.beta.deployments.archive(stringdeploymentID, DeploymentArchiveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}/archive
Run Deployment Now
client.beta.deployments.run(stringdeploymentID, DeploymentRunParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeploymentRun
POST/v1/deployments/{deployment_id}/run
Pause Deployment
client.beta.deployments.pause(stringdeploymentID, DeploymentPauseParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}/pause
Unpause Deployment
client.beta.deployments.unpause(stringdeploymentID, DeploymentUnpauseParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeployment
POST/v1/deployments/{deployment_id}/unpause

BetaDeployment Runs

List Deployment Runs
client.beta.deploymentRuns.list(DeploymentRunListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsDeploymentRun>
GET/v1/deployment_runs
Get Deployment Run
client.beta.deploymentRuns.retrieve(stringdeploymentRunID, DeploymentRunRetrieveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeploymentRun
GET/v1/deployment_runs/{deployment_run_id}

BetaVaults

Create Vault
client.beta.vaults.create(VaultCreateParamsparams, RequestOptionsoptions?): BetaManagedAgentsVault
POST/v1/vaults
List Vaults
client.beta.vaults.list(VaultListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsVault>
GET/v1/vaults
Get Vault
client.beta.vaults.retrieve(stringvaultID, VaultRetrieveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsVault
GET/v1/vaults/{vault_id}
Update Vault
client.beta.vaults.update(stringvaultID, VaultUpdateParamsparams, RequestOptionsoptions?): BetaManagedAgentsVault
POST/v1/vaults/{vault_id}
Delete Vault
client.beta.vaults.delete(stringvaultID, VaultDeleteParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeletedVault
DELETE/v1/vaults/{vault_id}
Archive Vault
client.beta.vaults.archive(stringvaultID, VaultArchiveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsVault
POST/v1/vaults/{vault_id}/archive

BetaVaultsCredentials

Create Credential
client.beta.vaults.credentials.create(stringvaultID, CredentialCreateParamsparams, RequestOptionsoptions?): BetaManagedAgentsCredential
POST/v1/vaults/{vault_id}/credentials
List Credentials
client.beta.vaults.credentials.list(stringvaultID, CredentialListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsCredential>
GET/v1/vaults/{vault_id}/credentials
Get Credential
client.beta.vaults.credentials.retrieve(stringcredentialID, CredentialRetrieveParamsparams, RequestOptionsoptions?): BetaManagedAgentsCredential
GET/v1/vaults/{vault_id}/credentials/{credential_id}
Update Credential
client.beta.vaults.credentials.update(stringcredentialID, CredentialUpdateParamsparams, RequestOptionsoptions?): BetaManagedAgentsCredential
POST/v1/vaults/{vault_id}/credentials/{credential_id}
Delete Credential
client.beta.vaults.credentials.delete(stringcredentialID, CredentialDeleteParamsparams, RequestOptionsoptions?): BetaManagedAgentsDeletedCredential
DELETE/v1/vaults/{vault_id}/credentials/{credential_id}
Archive Credential
client.beta.vaults.credentials.archive(stringcredentialID, CredentialArchiveParamsparams, RequestOptionsoptions?): BetaManagedAgentsCredential
POST/v1/vaults/{vault_id}/credentials/{credential_id}/archive
Validate Credential
client.beta.vaults.credentials.mcpOAuthValidate(stringcredentialID, CredentialMCPOAuthValidateParamsparams, RequestOptionsoptions?): BetaManagedAgentsCredentialValidation
POST/v1/vaults/{vault_id}/credentials/{credential_id}/mcp_oauth_validate

BetaMemory Stores

Create a memory store
client.beta.memoryStores.create(MemoryStoreCreateParamsparams, RequestOptionsoptions?): BetaManagedAgentsMemoryStore
POST/v1/memory_stores
List memory stores
client.beta.memoryStores.list(MemoryStoreListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsMemoryStore>
GET/v1/memory_stores
Retrieve a memory store
client.beta.memoryStores.retrieve(stringmemoryStoreID, MemoryStoreRetrieveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsMemoryStore
GET/v1/memory_stores/{memory_store_id}
Update a memory store
client.beta.memoryStores.update(stringmemoryStoreID, MemoryStoreUpdateParamsparams, RequestOptionsoptions?): BetaManagedAgentsMemoryStore
POST/v1/memory_stores/{memory_store_id}
Delete a memory store
client.beta.memoryStores.delete(stringmemoryStoreID, MemoryStoreDeleteParamsparams?, RequestOptionsoptions?): BetaManagedAgentsDeletedMemoryStore
DELETE/v1/memory_stores/{memory_store_id}
Archive a memory store
client.beta.memoryStores.archive(stringmemoryStoreID, MemoryStoreArchiveParamsparams?, RequestOptionsoptions?): BetaManagedAgentsMemoryStore
POST/v1/memory_stores/{memory_store_id}/archive

BetaMemory StoresMemories

Create a memory
client.beta.memoryStores.memories.create(stringmemoryStoreID, MemoryCreateParamsparams, RequestOptionsoptions?): BetaManagedAgentsMemory
POST/v1/memory_stores/{memory_store_id}/memories
List memories
client.beta.memoryStores.memories.list(stringmemoryStoreID, MemoryListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsMemoryListItem>
GET/v1/memory_stores/{memory_store_id}/memories
Retrieve a memory
client.beta.memoryStores.memories.retrieve(stringmemoryID, MemoryRetrieveParamsparams, RequestOptionsoptions?): BetaManagedAgentsMemory
GET/v1/memory_stores/{memory_store_id}/memories/{memory_id}
Update a memory
client.beta.memoryStores.memories.update(stringmemoryID, MemoryUpdateParamsparams, RequestOptionsoptions?): BetaManagedAgentsMemory
POST/v1/memory_stores/{memory_store_id}/memories/{memory_id}
Delete a memory
client.beta.memoryStores.memories.delete(stringmemoryID, MemoryDeleteParamsparams, RequestOptionsoptions?): BetaManagedAgentsDeletedMemory
DELETE/v1/memory_stores/{memory_store_id}/memories/{memory_id}

BetaMemory StoresMemory Versions

List memory versions
client.beta.memoryStores.memoryVersions.list(stringmemoryStoreID, MemoryVersionListParamsparams?, RequestOptionsoptions?): PageCursor<BetaManagedAgentsMemoryVersion>
GET/v1/memory_stores/{memory_store_id}/memory_versions
Retrieve a memory version
client.beta.memoryStores.memoryVersions.retrieve(stringmemoryVersionID, MemoryVersionRetrieveParamsparams, RequestOptionsoptions?): BetaManagedAgentsMemoryVersion
GET/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}
Redact a memory version
client.beta.memoryStores.memoryVersions.redact(stringmemoryVersionID, MemoryVersionRedactParamsparams, RequestOptionsoptions?): BetaManagedAgentsMemoryVersion
POST/v1/memory_stores/{memory_store_id}/memory_versions/{memory_version_id}/redact

BetaFiles

Upload File
client.beta.files.upload(FileUploadParamsparams, RequestOptionsoptions?): BetaFileMetadata
POST/v1/files
List Files
client.beta.files.list(FileListParamsparams?, RequestOptionsoptions?): Page<BetaFileMetadata>
GET/v1/files
Download File
client.beta.files.download(stringfileID, FileDownloadParamsparams?, RequestOptionsoptions?): Response
GET/v1/files/{file_id}/content
Get File Metadata
client.beta.files.retrieveMetadata(stringfileID, FileRetrieveMetadataParamsparams?, RequestOptionsoptions?): BetaFileMetadata
GET/v1/files/{file_id}
Delete File
client.beta.files.delete(stringfileID, FileDeleteParamsparams?, RequestOptionsoptions?): BetaDeletedFile
DELETE/v1/files/{file_id}

BetaSkills

Create Skill
client.beta.skills.create(SkillCreateParamsparams, RequestOptionsoptions?): SkillCreateResponse
POST/v1/skills
List Skills
client.beta.skills.list(SkillListParamsparams?, RequestOptionsoptions?): PageCursor<SkillListResponse>
GET/v1/skills
Get Skill
client.beta.skills.retrieve(stringskillID, SkillRetrieveParamsparams?, RequestOptionsoptions?): SkillRetrieveResponse
GET/v1/skills/{skill_id}
Delete Skill
client.beta.skills.delete(stringskillID, SkillDeleteParamsparams?, RequestOptionsoptions?): SkillDeleteResponse
DELETE/v1/skills/{skill_id}

BetaSkillsVersions

Create Skill Version
client.beta.skills.versions.create(stringskillID, VersionCreateParamsparams, RequestOptionsoptions?): VersionCreateResponse
POST/v1/skills/{skill_id}/versions
List Skill Versions
client.beta.skills.versions.list(stringskillID, VersionListParamsparams?, RequestOptionsoptions?): PageCursor<VersionListResponse>
GET/v1/skills/{skill_id}/versions
Download Skill Version Content
client.beta.skills.versions.download(stringversion, VersionDownloadParamsparams, RequestOptionsoptions?): Response
GET/v1/skills/{skill_id}/versions/{version}/content
Get Skill Version
client.beta.skills.versions.retrieve(stringversion, VersionRetrieveParamsparams, RequestOptionsoptions?): VersionRetrieveResponse
GET/v1/skills/{skill_id}/versions/{version}
Delete Skill Version
client.beta.skills.versions.delete(stringversion, VersionDeleteParamsparams, RequestOptionsoptions?): VersionDeleteResponse
DELETE/v1/skills/{skill_id}/versions/{version}

BetaWebhooks

Unwrap
client.beta.webhooks.unwrap(RequestOptionsoptions?): void

BetaUser Profiles

Create User Profile
client.beta.userProfiles.create(UserProfileCreateParamsparams, RequestOptionsoptions?): BetaUserProfile
POST/v1/user_profiles
List User Profiles
client.beta.userProfiles.list(UserProfileListParamsparams?, RequestOptionsoptions?): PageCursor<BetaUserProfile>
GET/v1/user_profiles
Get User Profile
client.beta.userProfiles.retrieve(stringuserProfileID, UserProfileRetrieveParamsparams?, RequestOptionsoptions?): BetaUserProfile
GET/v1/user_profiles/{user_profile_id}
Update User Profile
client.beta.userProfiles.update(stringuserProfileID, UserProfileUpdateParamsparams, RequestOptionsoptions?): BetaUserProfile
POST/v1/user_profiles/{user_profile_id}
Create Enrollment URL
client.beta.userProfiles.createEnrollmentURL(stringuserProfileID, UserProfileCreateEnrollmentURLParamsparams?, RequestOptionsoptions?): BetaUserProfileEnrollmentURL
POST/v1/user_profiles/{user_profile_id}/enrollment_url

BetaDreams

Create a Dream
client.beta.dreams.create(DreamCreateParamsparams, RequestOptionsoptions?): BetaDream
POST/v1/dreams
List Dreams
client.beta.dreams.list(DreamListParamsparams?, RequestOptionsoptions?): PageCursor<BetaDream>
GET/v1/dreams
Get a Dream
client.beta.dreams.retrieve(stringdreamID, DreamRetrieveParamsparams?, RequestOptionsoptions?): BetaDream
GET/v1/dreams/{dream_id}
Cancel a Dream
client.beta.dreams.cancel(stringdreamID, DreamCancelParamsparams?, RequestOptionsoptions?): BetaDream
POST/v1/dreams/{dream_id}/cancel
Archive a Dream
client.beta.dreams.archive(stringdreamID, DreamArchiveParamsparams?, RequestOptionsoptions?): BetaDream
POST/v1/dreams/{dream_id}/archive

BetaTunnels

Create Tunnel
client.beta.tunnels.create(TunnelCreateParamsparams, RequestOptionsoptions?): BetaTunnel
POST/v1/tunnels
Get Tunnel
client.beta.tunnels.retrieve(stringtunnelID, TunnelRetrieveParamsparams?, RequestOptionsoptions?): BetaTunnel
GET/v1/tunnels/{tunnel_id}
List Tunnels
client.beta.tunnels.list(TunnelListParamsparams?, RequestOptionsoptions?): PageCursor<BetaTunnel>
GET/v1/tunnels
Archive Tunnel
client.beta.tunnels.archive(stringtunnelID, TunnelArchiveParamsparams?, RequestOptionsoptions?): BetaTunnel
POST/v1/tunnels/{tunnel_id}/archive
Reveal Tunnel Token
client.beta.tunnels.revealToken(stringtunnelID, TunnelRevealTokenParamsparams?, RequestOptionsoptions?): BetaTunnelToken
POST/v1/tunnels/{tunnel_id}/reveal_token
Rotate Tunnel Token
client.beta.tunnels.rotateToken(stringtunnelID, TunnelRotateTokenParamsparams, RequestOptionsoptions?): BetaTunnelToken
POST/v1/tunnels/{tunnel_id}/rotate_token

BetaTunnelsCertificates

Create Tunnel Certificate
client.beta.tunnels.certificates.create(stringtunnelID, CertificateCreateParamsparams, RequestOptionsoptions?): BetaTunnelCertificate
POST/v1/tunnels/{tunnel_id}/certificates
Get Tunnel Certificate
client.beta.tunnels.certificates.retrieve(stringcertificateID, CertificateRetrieveParamsparams, RequestOptionsoptions?): BetaTunnelCertificate
GET/v1/tunnels/{tunnel_id}/certificates/{certificate_id}
List Tunnel Certificates
client.beta.tunnels.certificates.list(stringtunnelID, CertificateListParamsparams?, RequestOptionsoptions?): PageCursor<BetaTunnelCertificate>
GET/v1/tunnels/{tunnel_id}/certificates
Archive Tunnel Certificate
client.beta.tunnels.certificates.archive(stringcertificateID, CertificateArchiveParamsparams, RequestOptionsoptions?): BetaTunnelCertificate
POST/v1/tunnels/{tunnel_id}/certificates/{certificate_id}/archive

BetaOrganization

Get Current Organization
client.beta.organization.retrieve(RequestOptionsoptions?): BetaOrganization
GET/v1/organizations/me

BetaOrganizationAPI Keys

List API Keys
client.beta.organization.apiKeys.list(APIKeyListParamsquery?, RequestOptionsoptions?): Page<BetaAPIKey>
GET/v1/organizations/api_keys
Get API Key
client.beta.organization.apiKeys.retrieve(stringapiKeyID, RequestOptionsoptions?): BetaAPIKey
GET/v1/organizations/api_keys/{api_key_id}
Update API Key
client.beta.organization.apiKeys.update(stringapiKeyID, APIKeyUpdateParamsbody, RequestOptionsoptions?): BetaAPIKey
POST/v1/organizations/api_keys/{api_key_id}

BetaOrganizationExternal Keys

Create External Key
client.beta.organization.externalKeys.create(ExternalKeyCreateParamsbody, RequestOptionsoptions?): BetaExternalKey
POST/v1/organizations/external_keys
List External Keys
client.beta.organization.externalKeys.list(ExternalKeyListParamsquery?, RequestOptionsoptions?): PageCursor<BetaExternalKey>
GET/v1/organizations/external_keys
Get External Key
client.beta.organization.externalKeys.retrieve(stringexternalKeyID, RequestOptionsoptions?): BetaExternalKey
GET/v1/organizations/external_keys/{external_key_id}
Update External Key
client.beta.organization.externalKeys.update(stringexternalKeyID, ExternalKeyUpdateParamsbody, RequestOptionsoptions?): BetaExternalKey
POST/v1/organizations/external_keys/{external_key_id}
Delete External Key
client.beta.organization.externalKeys.delete(stringexternalKeyID, RequestOptionsoptions?): ExternalKeyDeleteResponse
DELETE/v1/organizations/external_keys/{external_key_id}
Validate External Key
client.beta.organization.externalKeys.validate(stringexternalKeyID, RequestOptionsoptions?): ExternalKeyValidateResponse
POST/v1/organizations/external_keys/{external_key_id}/validate

BetaOrganizationFederationIssuers

Create Federation Issuer
client.beta.organization.federation.issuers.create(IssuerCreateParamsparams, RequestOptionsoptions?): BetaFederationIssuer
POST/v1/organizations/federation_issuers
List Federation Issuers
client.beta.organization.federation.issuers.list(IssuerListParamsparams?, RequestOptionsoptions?): PageCursor<BetaFederationIssuer>
GET/v1/organizations/federation_issuers
Get Federation Issuer
client.beta.organization.federation.issuers.retrieve(stringfederationIssuerID, IssuerRetrieveParamsparams?, RequestOptionsoptions?): BetaFederationIssuer
GET/v1/organizations/federation_issuers/{federation_issuer_id}
Update Federation Issuer
client.beta.organization.federation.issuers.update(stringfederationIssuerID, IssuerUpdateParamsparams, RequestOptionsoptions?): BetaFederationIssuer
POST/v1/organizations/federation_issuers/{federation_issuer_id}
Archive Federation Issuer
client.beta.organization.federation.issuers.archive(stringfederationIssuerID, IssuerArchiveParamsparams?, RequestOptionsoptions?): BetaFederationIssuer
POST/v1/organizations/federation_issuers/{federation_issuer_id}/archive

BetaOrganizationFederationRules

Create Federation Rule
client.beta.organization.federation.rules.create(RuleCreateParamsparams, RequestOptionsoptions?): BetaFederationRule
POST/v1/organizations/federation_rules
List Federation Rules
client.beta.organization.federation.rules.list(RuleListParamsparams?, RequestOptionsoptions?): PageCursor<BetaFederationRule>
GET/v1/organizations/federation_rules
Get Federation Rule
client.beta.organization.federation.rules.retrieve(stringfederationRuleID, RuleRetrieveParamsparams?, RequestOptionsoptions?): BetaFederationRule
GET/v1/organizations/federation_rules/{federation_rule_id}
Update Federation Rule
client.beta.organization.federation.rules.update(stringfederationRuleID, RuleUpdateParamsparams, RequestOptionsoptions?): BetaFederationRule
POST/v1/organizations/federation_rules/{federation_rule_id}
Archive Federation Rule
client.beta.organization.federation.rules.archive(stringfederationRuleID, RuleArchiveParamsparams?, RequestOptionsoptions?): BetaFederationRule
POST/v1/organizations/federation_rules/{federation_rule_id}/archive

BetaOrganizationFederationRulesWorkspaces

Add Federation Rule Workspace
client.beta.organization.federation.rules.workspaces.add(stringfederationRuleID, WorkspaceAddParamsparams, RequestOptionsoptions?): BetaFederationRuleWorkspace
POST/v1/organizations/federation_rules/{federation_rule_id}/workspaces
List Federation Rule Workspaces
client.beta.organization.federation.rules.workspaces.list(stringfederationRuleID, WorkspaceListParamsparams?, RequestOptionsoptions?): PageCursor<BetaFederationRuleWorkspace>
GET/v1/organizations/federation_rules/{federation_rule_id}/workspaces
Remove Federation Rule Workspace
client.beta.organization.federation.rules.workspaces.remove(stringworkspaceID, WorkspaceRemoveParamsparams, RequestOptionsoptions?): WorkspaceRemoveResponse
DELETE/v1/organizations/federation_rules/{federation_rule_id}/workspaces/{workspace_id}

BetaOrganizationInvites

Create Invite
client.beta.organization.invites.create(InviteCreateParamsbody, RequestOptionsoptions?): BetaOrganizationInvite
POST/v1/organizations/invites
List Invites
client.beta.organization.invites.list(InviteListParamsquery?, RequestOptionsoptions?): Page<BetaOrganizationInvite>
GET/v1/organizations/invites
Get Invite
client.beta.organization.invites.retrieve(stringinviteID, RequestOptionsoptions?): BetaOrganizationInvite
GET/v1/organizations/invites/{invite_id}
Delete Invite
client.beta.organization.invites.delete(stringinviteID, RequestOptionsoptions?): InviteDeleteResponse
DELETE/v1/organizations/invites/{invite_id}

BetaOrganizationService Accounts

Create Service Account
client.beta.organization.serviceAccounts.create(ServiceAccountCreateParamsparams, RequestOptionsoptions?): BetaServiceAccount
POST/v1/organizations/service_accounts
List Service Accounts
client.beta.organization.serviceAccounts.list(ServiceAccountListParamsparams?, RequestOptionsoptions?): PageCursor<BetaServiceAccount>
GET/v1/organizations/service_accounts
Get Service Account
client.beta.organization.serviceAccounts.retrieve(stringserviceAccountID, ServiceAccountRetrieveParamsparams?, RequestOptionsoptions?): BetaServiceAccount
GET/v1/organizations/service_accounts/{service_account_id}
Update Service Account
client.beta.organization.serviceAccounts.update(stringserviceAccountID, ServiceAccountUpdateParamsparams, RequestOptionsoptions?): BetaServiceAccount
POST/v1/organizations/service_accounts/{service_account_id}
Archive Service Account
client.beta.organization.serviceAccounts.archive(stringserviceAccountID, ServiceAccountArchiveParamsparams?, RequestOptionsoptions?): BetaServiceAccount
POST/v1/organizations/service_accounts/{service_account_id}/archive

BetaOrganizationService AccountsWorkspaces

Add Workspace To Service Account
client.beta.organization.serviceAccounts.workspaces.add(stringserviceAccountID, WorkspaceAddParamsparams, RequestOptionsoptions?): BetaServiceAccountWorkspaceMember
POST/v1/organizations/service_accounts/{service_account_id}/workspaces
List Workspaces For Service Account
client.beta.organization.serviceAccounts.workspaces.list(stringserviceAccountID, WorkspaceListParamsparams?, RequestOptionsoptions?): PageCursor<BetaServiceAccountWorkspaceMember>
GET/v1/organizations/service_accounts/{service_account_id}/workspaces
Remove Workspace From Service Account
client.beta.organization.serviceAccounts.workspaces.remove(stringworkspaceID, WorkspaceRemoveParamsparams, RequestOptionsoptions?): WorkspaceRemoveResponse
DELETE/v1/organizations/service_accounts/{service_account_id}/workspaces/{workspace_id}

BetaOrganizationUsers

List Users
client.beta.organization.users.list(UserListParamsquery?, RequestOptionsoptions?): Page<BetaOrganizationUser>
GET/v1/organizations/users
Get User
client.beta.organization.users.retrieve(stringuserID, RequestOptionsoptions?): BetaOrganizationUser
GET/v1/organizations/users/{user_id}
Update User
client.beta.organization.users.update(stringuserID, UserUpdateParamsbody, RequestOptionsoptions?): BetaOrganizationUser
POST/v1/organizations/users/{user_id}
Remove User
client.beta.organization.users.remove(stringuserID, RequestOptionsoptions?): UserRemoveResponse
DELETE/v1/organizations/users/{user_id}

BetaOrganizationWorkspaces

List Workspaces
client.beta.organization.workspaces.list(WorkspaceListParamsquery?, RequestOptionsoptions?): Page<BetaWorkspace>
GET/v1/organizations/workspaces
Create Workspace
client.beta.organization.workspaces.create(WorkspaceCreateParamsparams, RequestOptionsoptions?): BetaWorkspace
POST/v1/organizations/workspaces
Get Workspace
client.beta.organization.workspaces.retrieve(stringworkspaceID, RequestOptionsoptions?): BetaWorkspace
GET/v1/organizations/workspaces/{workspace_id}
Update Workspace
client.beta.organization.workspaces.update(stringworkspaceID, WorkspaceUpdateParamsbody, RequestOptionsoptions?): BetaWorkspace
POST/v1/organizations/workspaces/{workspace_id}
Archive Workspace
client.beta.organization.workspaces.archive(stringworkspaceID, RequestOptionsoptions?): BetaWorkspace
POST/v1/organizations/workspaces/{workspace_id}/archive

BetaOrganizationWorkspacesRate Limits

List Workspace Rate Limits
client.beta.organization.workspaces.rateLimits.list(stringworkspaceID, RateLimitListParamsquery?, RequestOptionsoptions?): PageCursor<BetaWorkspaceRateLimit>
GET/v1/organizations/workspaces/{workspace_id}/rate_limits

BetaOrganizationWorkspacesMembers

List Workspace Members
client.beta.organization.workspaces.members.list(stringworkspaceID, MemberListParamsquery?, RequestOptionsoptions?): Page<BetaWorkspaceMember>
GET/v1/organizations/workspaces/{workspace_id}/members
Create Workspace Member
client.beta.organization.workspaces.members.add(stringworkspaceID, MemberAddParamsbody, RequestOptionsoptions?): BetaWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/members
Get Workspace Member
client.beta.organization.workspaces.members.retrieve(stringuserID, MemberRetrieveParamsparams, RequestOptionsoptions?): BetaWorkspaceMember
GET/v1/organizations/workspaces/{workspace_id}/members/{user_id}
Update Workspace Member
client.beta.organization.workspaces.members.update(stringuserID, MemberUpdateParamsparams, RequestOptionsoptions?): BetaWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/members/{user_id}
Delete Workspace Member
client.beta.organization.workspaces.members.remove(stringuserID, MemberRemoveParamsparams, RequestOptionsoptions?): MemberRemoveResponse
DELETE/v1/organizations/workspaces/{workspace_id}/members/{user_id}

BetaOrganizationWorkspacesService Accounts

List Service Account Workspace Members
client.beta.organization.workspaces.serviceAccounts.list(stringworkspaceID, ServiceAccountListParamsparams?, RequestOptionsoptions?): PageCursor<BetaServiceAccountWorkspaceMember>
GET/v1/organizations/workspaces/{workspace_id}/service_accounts
Create Service Account Workspace Member
client.beta.organization.workspaces.serviceAccounts.add(stringworkspaceID, ServiceAccountAddParamsparams, RequestOptionsoptions?): BetaServiceAccountWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/service_accounts
Get Service Account Workspace Member
client.beta.organization.workspaces.serviceAccounts.retrieve(stringserviceAccountID, ServiceAccountRetrieveParamsparams, RequestOptionsoptions?): BetaServiceAccountWorkspaceMember
GET/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}
Update Service Account Workspace Member
client.beta.organization.workspaces.serviceAccounts.update(stringserviceAccountID, ServiceAccountUpdateParamsparams, RequestOptionsoptions?): BetaServiceAccountWorkspaceMember
POST/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}
Delete Service Account Workspace Member
client.beta.organization.workspaces.serviceAccounts.remove(stringserviceAccountID, ServiceAccountRemoveParamsparams, RequestOptionsoptions?): ServiceAccountRemoveResponse
DELETE/v1/organizations/workspaces/{workspace_id}/service_accounts/{service_account_id}

BetaOrganizationRate Limits

List Organization Rate Limits
client.beta.organization.rateLimits.list(RateLimitListParamsquery?, RequestOptionsoptions?): PageCursor<BetaOrganizationRateLimit>
GET/v1/organizations/rate_limits