> ## Documentation Index
> Fetch the complete documentation index at: https://paper.brimble.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Get sandbox list prices

> The list price of a sandbox: the hourly rate per vCPU and per GB of memory, and what each sandbox size costs per hour at those rates.

Sandboxes are billed by the second with no minimum, from the moment they are ready until they are paused or destroyed. A paused sandbox is not billed for CPU or memory. Plans may include an amount of sandbox usage; these are the rates beyond it.

No authentication required.



## OpenAPI

````yaml api-reference/core.openapi.yaml GET /v1/sandbox-pricing
openapi: 3.0.3
info:
  title: Brimble API
  version: 1.0.0
  description: >
    The Brimble API lets you deploy and manage projects, databases, domains,
    sandboxes, object storage and more.


    ## Base URL


    All endpoints are relative to `https://api.brimble.io/core`, for example
    `GET https://api.brimble.io/core/v1/projects`.


    ## Authentication


    Create an API key in the dashboard under **Settings → API keys** and send it
    in the `x-brimble-key` header:


    ```

    x-brimble-key: <your API key>

    ```


    Each API key carries permission scopes such as `project.read` or
    `project.deploy`. Every endpoint lists the scope it needs; a key without
    that scope gets `403`. Dashboard session tokens (`Authorization: Bearer
    <token>`) are also accepted, but integrations should use API keys.


    ## Teams


    Endpoints act on your personal workspace unless you pass a team. Most
    endpoints accept `teamId` (as a query parameter, or in the body for writes).
    API keys created for a team act in that team. Inside a team, your team role
    must also allow the action; each endpoint lists the team permission it
    checks.


    ## Responses


    Successful responses are JSON with this shape:


    ```json

    { "message": "Projects fetched", "data": { } }

    ```


    Errors return a `message`:


    ```json

    { "message": "Project not found", "data": {} }

    ```


    Requests that fail validation return `400` with every invalid field:


    ```json

    { "errors": [{ "type": "field", "msg": "Project name should be provided",
    "path": "name", "location": "body" }] }

    ```


    ## Rate limits


    Requests made with an API key are rate limited. Responses include
    `X-RateLimit-Limit`, `X-RateLimit-Remaining`, `X-RateLimit-Reset` and
    `X-RateLimit-Bucket`. Command execution and file transfer endpoints use
    separate buckets.


    ## Idempotency


    Endpoints that accept an `Idempotency-Key` header return the original result
    when retried with the same key and body, instead of repeating the operation.


    ## Streaming


    Command execution endpoints can stream output as Server-Sent Events
    (`text/event-stream`). Each event is `data: <json>` where the JSON has a
    `type` of `stdout`, `stderr`, `done` or `error`.


    ## Webhooks


    To receive events instead of polling, configure a webhook with `PATCH
    /v1/webhooks`. See the [Webhooks guide](/webhooks/overview) and the [Webhook
    events reference](/webhooks/events) for every payload.
  contact:
    name: Brimble
    url: https://brimble.io
servers:
  - url: https://api.brimble.io/core
    description: Production
security:
  - ApiKeyAuth: []
  - BearerAuth: []
tags:
  - name: Projects
    description: Create, deploy, configure and manage projects.
  - name: Deployments and Logs
    description: Deployment history, build logs and request logs.
  - name: Environments
    description: Project environments (production, staging, previews) and their variables.
  - name: Secrets
    description: >-
      Secrets (environment variables) set on a single project. Not to be
      confused with Environments, which group projects into production, staging
      and preview. Secret values are encrypted at rest and returned encrypted;
      use `POST /v1/decrypt` to read them.
  - name: Webhooks
    description: >-
      Receive events from Brimble at your own endpoint (or a Discord or Slack
      channel). Configure the destination and events with `PATCH /v1/webhooks`;
      use `*` to receive every event.


      See the [Webhooks guide](/webhooks/overview) for setup, and the [Webhook
      events reference](/webhooks/events) for the payload each event delivers.


      | Event | Sent when |

      | --- | --- |

      | `project.created` | A project is created |

      | `project.updated` | A project is updated |

      | `project.deleted` | A project is deleted |

      | `project.domain.updated` | A project domain changes |

      | `deployment.created` | A deployment is queued |

      | `deployment.started` | A deployment starts |

      | `deployment.success` | A deployment succeeds |

      | `deployment.failed` | A deployment fails |

      | `environment.variables.added` | Environment variables are added |

      | `environment.variables.updated` | Environment variables are updated |

      | `environment.variables.deleted` | Environment variables are deleted |

      | `domain.created` | A domain is added |

      | `domain.purchased` | A domain is purchased |

      | `domain.renewed` | A domain is renewed |

      | `domain.expired` | A domain expires |

      | `dns.record.created` | A DNS record is created |

      | `dns.record.updated` | A DNS record is updated |

      | `dns.record.deleted` | A DNS record is deleted |

      | `database.created` | A database is created |

      | `database.backup.completed` | A database backup completes |

      | `autoscaling.group.created` | An autoscaling rule is created |

      | `autoscaling.group.updated` | An autoscaling rule is updated |

      | `autoscaling.group.deleted` | An autoscaling rule is deleted |

      | `payment.successful` | A payment succeeds |

      | `payment.failed` | A payment fails |


      Test deliveries sent with `POST /v1/webhooks/test` include the header
      `X-Brimble-Test: true`.
  - name: Git Providers
    description: Connected git accounts, repositories and linking repositories to projects.
  - name: Domains
    description: Custom domains, DNS records and domain registration.
  - name: Databases
    description: 'Managed databases: provisioning, backups, users and linking to projects.'
  - name: Log Drains
    description: Stream logs to external destinations.
  - name: Sandboxes
    description: Isolated sandboxes for running code, with files and snapshots.
  - name: CI Runners
    description: Run GitHub Actions jobs for an organization on Brimble sandboxes.
  - name: Object Storage
    description: S3-compatible buckets, objects and credentials.
  - name: Scaling and Networking
    description: Autoscaling rules, networking and CDN cache, and rate limits.
  - name: Teams
    description: Teams, members, invitations and roles.
  - name: Tags
    description: Label projects with tags and filter by them.
  - name: Billing
    description: Costs per resource in FOCUS 1.2 format, for cost tools such as CostGraph.
  - name: Catalog
    description: Regions, frameworks and plans. No authentication required.
paths:
  /v1/sandbox-pricing:
    get:
      tags:
        - Catalog
      summary: Get sandbox list prices
      description: >-
        The list price of a sandbox: the hourly rate per vCPU and per GB of
        memory, and what each sandbox size costs per hour at those rates.


        Sandboxes are billed by the second with no minimum, from the moment they
        are ready until they are paused or destroyed. A paused sandbox is not
        billed for CPU or memory. Plans may include an amount of sandbox usage;
        these are the rates beyond it.


        No authentication required.
      operationId: getSandboxPricing
      responses:
        '200':
          description: Sandbox pricing fetched successfully
          content:
            application/json:
              schema:
                type: object
                required:
                  - message
                  - data
                properties:
                  message:
                    type: string
                  data:
                    type: object
                    properties:
                      currency:
                        type: string
                        example: USD
                      billing_increment_seconds:
                        type: integer
                        example: 1
                      minimum_billed_seconds:
                        type: integer
                        example: 0
                      billed_while_paused:
                        type: boolean
                        example: false
                      rates:
                        type: object
                        properties:
                          cpu_per_vcpu_hour:
                            type: number
                            example: 0.015
                          memory_per_gb_hour:
                            type: number
                            example: 0.008
                          snapshot_storage_per_gb_month:
                            type: number
                            example: 0.25
                      sizes:
                        type: array
                        items:
                          type: object
                          properties:
                            name:
                              type: string
                              example: sbx.micro
                            display_name:
                              type: string
                              example: Micro
                            vcpu:
                              type: number
                              example: 1
                            memory_gb:
                              type: number
                              example: 1
                            disk_gb:
                              type: number
                              example: 2
                            price_per_hour:
                              type: number
                              example: 0.023
        '500':
          $ref: '#/components/responses/ServerError'
      security: []
components:
  responses:
    ServerError:
      description: Unexpected server error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
  schemas:
    ErrorResponse:
      type: object
      required:
        - message
      properties:
        message:
          type: string
          description: Human-readable error message.
          example: Project not found
        data:
          type: object
          description: Always empty on errors.
          example: {}
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-brimble-key
      description: >-
        API key created in the dashboard under Settings → API keys. Each key
        carries permission scopes; every endpoint lists the scope it needs.
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: Dashboard session token. Use an API key for integrations.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.