> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-5e9cc07a-preview-cbfron-1772840960-d2a2597.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Get sandbox resource usage and quota limits

> Return current resource consumption and organisation quota limits.

Sandbox counts include both direct claims and warmpool replicas.
For self-hosted deployments limit fields are 0 (quotas not enforced).



## OpenAPI

````yaml https://api.host.langchain.com/openapi.json get /v2/sandboxes/usage
openapi: 3.1.0
info:
  title: LangSmith Deployment Control Plane API
  description: >
    The LangSmith Deployment Control Plane API is used to programmatically
    create and manage

    Agent Server deployments. For example, the APIs can be orchestrated to

    create custom CI/CD workflows.


    ## Host

    https://api.host.langchain.com


    ## Authentication

    To authenticate with the LangSmith Deployment Control Plane API, set the
    `X-Api-Key` header

    to a valid [LangSmith API
    key](https://docs.langchain.com/langsmith/create-account-api-key#create-an-api-key).


    ## Versioning

    Each endpoint path is prefixed with a version (e.g. `v1`, `v2`).


    ## Quick Start

    1. Call `POST /v2/deployments` to create a new Deployment. The response body
    contains the Deployment ID (`id`) and the ID of the latest (and first)
    revision (`latest_revision_id`).

    1. Call `GET /v2/deployments/{deployment_id}` to retrieve the Deployment.
    Set `deployment_id` in the URL to the value of Deployment ID (`id`).

    1. Poll for revision `status` until `status` is `DEPLOYED` by calling `GET
    /v2/deployments/{deployment_id}/revisions/{latest_revision_id}`.

    1. Call `PATCH /v2/deployments/{deployment_id}` to update the deployment.
  version: 0.1.0
servers: []
security: []
paths:
  /v2/sandboxes/usage:
    get:
      tags:
        - Sandboxes (v2)
      summary: Get sandbox resource usage and quota limits
      description: |-
        Return current resource consumption and organisation quota limits.

        Sandbox counts include both direct claims and warmpool replicas.
        For self-hosted deployments limit fields are 0 (quotas not enforced).
      operationId: get_usage_v2_sandboxes_usage_get
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SandboxUsageResponse'
      security:
        - API Key: []
        - Tenant ID: []
        - Bearer Auth: []
components:
  schemas:
    SandboxUsageResponse:
      properties:
        sandboxes_used:
          type: integer
          title: Sandboxes Used
          description: Total sandbox instances (claims + warmpool replicas)
        sandbox_direct_count:
          type: integer
          title: Sandbox Direct Count
          description: Number of directly created sandbox instances
        sandbox_pool_replicas_count:
          type: integer
          title: Sandbox Pool Replicas Count
          description: Number of sandbox instances from warm pool replicas
        sandboxes_limit:
          type: integer
          title: Sandboxes Limit
          description: Organization quota for max sandbox instances (0 = unlimited)
        volumes_used:
          type: integer
          title: Volumes Used
          description: Number of volumes
        volumes_limit:
          type: integer
          title: Volumes Limit
          description: Organization quota for max volumes (0 = unlimited)
        templates_count:
          type: integer
          title: Templates Count
          description: Number of templates
        pools_count:
          type: integer
          title: Pools Count
          description: Number of warm pools
        registries_count:
          type: integer
          title: Registries Count
          description: Number of registries
        cpu_used_millicores:
          type: integer
          title: Cpu Used Millicores
          description: Total CPU in millicores across all sandboxes
        cpu_limit_millicores:
          type: integer
          title: Cpu Limit Millicores
          description: Organization CPU quota in millicores (0 = unlimited)
        memory_used_bytes:
          type: integer
          title: Memory Used Bytes
          description: Total memory in bytes across all sandboxes
        memory_limit_bytes:
          type: integer
          title: Memory Limit Bytes
          description: Organization memory quota in bytes (0 = unlimited)
        storage_used_bytes:
          type: integer
          title: Storage Used Bytes
          description: Total volume storage in bytes
        storage_limit_bytes:
          type: integer
          title: Storage Limit Bytes
          description: Organization storage quota in bytes (0 = unlimited)
      type: object
      required:
        - sandboxes_used
        - sandbox_direct_count
        - sandbox_pool_replicas_count
        - sandboxes_limit
        - volumes_used
        - volumes_limit
        - templates_count
        - pools_count
        - registries_count
        - cpu_used_millicores
        - cpu_limit_millicores
        - memory_used_bytes
        - memory_limit_bytes
        - storage_used_bytes
        - storage_limit_bytes
      title: SandboxUsageResponse
      description: |-
        Response model for sandbox resource usage and quota limits.

        Usage fields reflect current consumption across all sandboxes (claims +
        warmpool replicas) and volumes in the workspace. Limit fields come from
        the organization-level quota configuration (Metronome).

        For self-hosted deployments where quotas are not enforced, limit fields
        are ``0``.

````