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

# Undelete a billing account

> Cancel the deletion of a billing account.



## OpenAPI

````yaml /openapi.json post /v1/billing-accounts/{id}:undelete
openapi: 3.0.3
info:
  description: >-
    The CUDO Compute API is organized around
    [REST](http://en.wikipedia.org/wiki/Representational_State_Transfer). Our
    API uses predictable resource-oriented URLs, accepts and returns
    [JSON](http://www.json.org/)-encoded requests and responses, and uses
    standard HTTP response codes, authentication, and verbs where possible.
  title: CUDO Compute service
  version: 1.0.0
servers:
  - url: https://rest.compute.cudo.org/
security:
  - bearerAuth: []
tags:
  - description: API keys allow you to authenticate requests with the CUDO Compute API.
    name: API keys
  - description: >
      Billing accounts hold all billing related information such as credit
      balance, payment methods & transaction history. You can use the same
      billing account for multiple projects.


      Related guide: [Billing](https://www.cudocompute.com/docs/billing)
    name: Billing
  - description: >
      Clusters are high-performance computing environments that can be used to
      run large-scale parallel and distributed applications.


      Related guide: [Clusters](https://www.cudocompute.com/docs/clusters)
    name: Clusters
  - description: >
      Storage disks are virtual disks that operate just like physical disks. You
      can attach & detach created storage disks to and from virtual machines in
      the same data center.


      Related guide: [Disks](https://www.cudocompute.com/docs/disks)
    name: Disks
  - description: |
      Images are boot disk templates used to create virtual machines.

      Related guide: [Images](https://www.cudocompute.com/docs/images)
    name: Images
  - description: >
      Bare-metal machines are dedicated physical servers for high-performance
      computing, offering full control and isolation from other users.


      Related guide: [Bare metal](https://www.cudocompute.com/docs/bare-metal)
    name: Machines
  - description: >
      Private networks allow you to securely connect your virtual machines
      together.


      Related guide: [Networks](https://www.cudocompute.com/docs/networks)
    name: Networks
  - description: >
      Store large amounts of unstructured data, including audio, video and user
      uploaded files.


      Related guide: [Object
      storage](https://www.cudocompute.com/docs/object-storage)
    name: Object storage
  - description: >
      Projects are containers for cloud resources, such as virtual machines &
      clusters.
    name: Projects
  - description: Operations for searching available compute resources.
    name: Resources
  - description: >
      SSH keys are access credentials that are automatically added to bare-metal
      and virtual machines you create.
    name: SSH keys
  - description: Operations related to user accounts and identity verification.
    name: Users
  - description: >
      A virtual machine (VM) is a software emulation of a physical computer.


      Related guide: [Virtual
      machines](https://www.cudocompute.com/docs/virtual-machines)
    name: Virtual machines
  - description: >
      Volumes are high-performance Network File Systems that allow cluster
      machines to share training data and model checkpoints.


      Related guide: [Volumes](https://www.cudocompute.com/docs/volumes)
    name: Volumes
paths:
  /v1/billing-accounts/{id}:undelete:
    post:
      tags:
        - Billing
      summary: Undelete a billing account
      description: Cancel the deletion of a billing account.
      operationId: UndeleteBillingAccount
      parameters:
        - in: path
          name: id
          required: true
          schema:
            type: string
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BillingAccount'
          description: A successful response.
        default:
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Status'
          description: An unexpected error response.
components:
  schemas:
    BillingAccount:
      properties:
        billingAddress:
          $ref: '#/components/schemas/BillingAddress'
        billingThreshold:
          $ref: '#/components/schemas/Decimal'
        createBy:
          readOnly: true
          type: string
        createTime:
          format: date-time
          readOnly: true
          type: string
        creditBalance:
          $ref: '#/components/schemas/Decimal'
        creditBalanceRecharge:
          $ref: '#/components/schemas/CreditBalanceRecharge'
        deleteTime:
          format: date-time
          readOnly: true
          type: string
        displayName:
          type: string
        hourlySpendLimit:
          $ref: '#/components/schemas/Decimal'
        hourlySpendRate:
          $ref: '#/components/schemas/Decimal'
        id:
          readOnly: true
          type: string
        invoiceTime:
          format: date-time
          readOnly: true
          type: string
        monthlySpend:
          readOnly: true
          type: string
        monthlySpendLimit:
          $ref: '#/components/schemas/Decimal'
        nextInvoiceTotal:
          $ref: '#/components/schemas/Decimal'
        paymentTerms:
          $ref: '#/components/schemas/PaymentTerms'
        purgeTime:
          format: date-time
          readOnly: true
          type: string
        state:
          $ref: '#/components/schemas/BillingAccountState'
        stripeRef:
          type: string
        taxId:
          $ref: '#/components/schemas/TaxId'
      type: object
    Status:
      properties:
        code:
          format: int32
          type: integer
        details:
          items:
            $ref: '#/components/schemas/Any'
          type: array
        message:
          type: string
      type: object
    BillingAddress:
      properties:
        city:
          type: string
        country:
          type: string
        line1:
          type: string
        line2:
          type: string
        name:
          type: string
        phone:
          type: string
        postalCode:
          type: string
        state:
          type: string
      type: object
    Decimal:
      description: >-
        A representation of a decimal value, such as 2.5. Clients may convert
        values

        into language-native decimal formats, such as Java's [BigDecimal][] or

        Python's [decimal.Decimal][].


        [BigDecimal]:

        https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/math/BigDecimal.html

        [decimal.Decimal]: https://docs.python.org/3/library/decimal.html
      properties:
        value:
          description: >-
            The decimal value, as a string.


            The string representation consists of an optional sign, `+`
            (`U+002B`)

            or `-` (`U+002D`), followed by a sequence of zero or more decimal
            digits

            ("the integer"), optionally followed by a fraction, optionally
            followed

            by an exponent.


            The fraction consists of a decimal point followed by zero or more
            decimal

            digits. The string must contain at least one digit in either the
            integer

            or the fraction. The number formed by the sign, the integer and the

            fraction is referred to as the significand.


            The exponent consists of the character `e` (`U+0065`) or `E`
            (`U+0045`)

            followed by one or more decimal digits.


            Services **should** normalize decimal values before storing them by:

              - Removing an explicitly-provided `+` sign (`+2.5` -> `2.5`).
              - Replacing a zero-length integer value with `0` (`.5` -> `0.5`).
              - Coercing the exponent character to lower-case (`2.5E8` -> `2.5e8`).
              - Removing an explicitly-provided zero exponent (`2.5e0` -> `2.5`).

            Services **may** perform additional normalization based on its own
            needs

            and the internal decimal implementation selected, such as shifting
            the

            decimal point and exponent value together (example: `2.5e-1` <->
            `0.25`).

            Additionally, services **may** preserve trailing zeroes in the
            fraction

            to indicate increased precision, but are not required to do so.


            Note that only the `.` character is supported to divide the integer

            and the fraction; `,` **should not** be supported regardless of
            locale.

            Additionally, thousand separators **should not** be supported. If a

            service does support them, values **must** be normalized.


            The ENBF grammar is:

                DecimalString =
                  [Sign] Significand [Exponent];

                Sign = '+' | '-';

                Significand =
                  Digits ['.'] [Digits] | [Digits] '.' Digits;

                Exponent = ('e' | 'E') [Sign] Digits;

                Digits = { '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' };

            Services **should** clearly document the range of supported values,
            the

            maximum supported precision (total number of digits), and, if
            applicable,

            the scale (number of digits after the decimal point), as well as how
            it

            behaves when receiving out-of-bounds values.


            Services **may** choose to accept values passed as input even when
            the

            value has a higher precision or scale than the service supports, and

            **should** round the value to fit the supported scale.
            Alternatively, the

            service **may** error with `400 Bad Request` (`INVALID_ARGUMENT` in
            gRPC)

            if precision would be lost.


            Services **should** error with `400 Bad Request` (`INVALID_ARGUMENT`
            in

            gRPC) if the service receives a value outside of the supported
            range.
          type: string
      type: object
    CreditBalanceRecharge:
      properties:
        autoRecharge:
          type: boolean
        high:
          $ref: '#/components/schemas/Decimal'
        low:
          $ref: '#/components/schemas/Decimal'
        transaction:
          $ref: '#/components/schemas/Transaction'
      required:
        - low
        - high
        - autoRecharge
      type: object
    PaymentTerms:
      default: PAYMENT_TERMS_UNSPECIFIED
      enum:
        - PAYMENT_TERMS_UNSPECIFIED
        - PAYMENT_TERMS_PREPAID
        - PAYMENT_TERMS_INVOICE
      type: string
    BillingAccountState:
      default: STATE_UNSPECIFIED
      enum:
        - STATE_UNSPECIFIED
        - STATE_ACTIVE
        - STATE_SUSPENDED_ABUSE
        - STATE_SUSPENDED_PAYMENT
        - STATE_DELETED
      type: string
    TaxId:
      properties:
        id:
          readOnly: true
          type: string
        type:
          type: string
        value:
          type: string
      type: object
    Any:
      additionalProperties: {}
      properties:
        '@type':
          type: string
      type: object
    Transaction:
      properties:
        amount:
          $ref: '#/components/schemas/Decimal'
        createTime:
          format: date-time
          type: string
        description:
          type: string
        id:
          type: string
        lastPaymentError:
          $ref: '#/components/schemas/LastPaymentError'
        latestCharge:
          $ref: '#/components/schemas/Charge'
        status:
          type: string
        succeeded:
          type: boolean
      required:
        - id
        - amount
        - description
        - createTime
        - status
        - succeeded
        - latestCharge
        - lastPaymentError
      type: object
    LastPaymentError:
      properties:
        code:
          type: string
        declineCode:
          type: string
      required:
        - code
        - declineCode
      type: object
    Charge:
      properties:
        amount:
          $ref: '#/components/schemas/Decimal'
        createTime:
          format: date-time
          type: string
        failureCode:
          type: string
        paid:
          type: boolean
        refunded:
          type: boolean
        status:
          type: string
      required:
        - amount
        - createTime
        - paid
        - refunded
        - status
      type: object
  securitySchemes:
    bearerAuth:
      description: >-
        API key authentication. API keys should be passed using the format
        `Bearer API_KEY`.
      in: header
      name: Authorization
      type: apiKey

````