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

# Terminate Card

> Close a card permanently. The card stops working at once and cannot be reactivated. Any balance on it is returned by the card issuer and credited back automatically, usually within a minute; `balance_refund` in the response says whether that is still to come. Terminating a card that is already terminated returns 200 with `already_terminated: true`, so the call is safe to retry.

## Overview

Close a card permanently. Use this when a customer no longer needs a card, or when you want to close it and return its balance. Unlike [freezing](/api-reference/cards/freeze.md), termination cannot be undone.

## What happens to the balance

You do not need to withdraw first. A card cannot be withdrawn below USD 1.00, but termination returns everything left on the card.

* The card issuer returns the balance and it is credited back automatically, the same way a [withdrawal](/api-reference/cards/withdraw.md) is credited. This usually takes less than a minute.
* `balance_refund` in the response tells you where it stands:
  * `none`: there was nothing on the card.
  * `pending`: the balance is on its way back. You receive the `card.termination_refund` webhook when it lands.
  * `refunded`: it was credited during this request.
* You also receive `card.terminated` when the card is closed.

## When a card cannot be terminated

| `data.code` | Status | Meaning |
| - | - | - |
| `card_not_found` | 404 | No card with this id belongs to your business. |
| `card_not_issued` | 409 | The card was never issued (still being created, or its KYC failed), so there is nothing to terminate. A card that fails KYC is cancelled and refunded automatically. |
| `card_movement_pending` | 409 | A funding or withdrawal on the card is still processing. Try again once it has settled. |
| `card_frozen_by_platnova` | 403 | Platnova froze this card. Contact support. |
| `card_cannot_be_terminated` | 409 | This card can't be terminated through the API. Contact support. |

Terminating a card that is already terminated returns `200` with `already_terminated: true`, so the call is safe to retry.


## OpenAPI

````yaml PUT /v1/cards/{card_id}/terminate
openapi: 3.1.0
info:
  title: API
  version: 1.0.0
  description: >-
    Platnova's Business API allows businesses to issue virtual accounts and
    cards to their employees, vendors, or retail customers. It allows businesses
    to streamline the process of issuing cards, manage spending, and track
    transactions. The API documentation provides information on how to integrate
    our virtual card issuing system into a business's existing systems and
    outlines the features and functionalities of the API, including card and
    account creation, management, and reporting. It also provides technical
    specifications, such as API requests, responses, and authentication
    processes.


    The API documentation is intended for developers and IT teams to use in
    order to effectively implement Platnova solutions into their business
    processes.


    # Authentication/Authorization


    To access any of the resources on the `{BaseUrl}/v1/`, the client has to
    pass pre-defined headers for authentication and authorization.


    The API is secure and only authorized clients can consume the service. There
    are API keys assigned to every business and JWT tokens assigned to every
    account for authentication/authorization.


    ## Bearer Token


    Requests may accept jwt tokens as below.


    ``` json

    Authorization: Bearer <jwt token>

     ```

    ## API Key


    Requests may acccept an api key either in the request headers or as a query
    parameter. Some requests cannot be authorized using an API key.


    ``` json

    X-API-KEY: <api key>

     ```

    OR


    ``` json

    ?api-key=<api key>

     ```

    # Base URL


    [https://sandbox.api.platnova.co](https://sandbox.api.platnova.co)


    # Errors


    Unauthorized API key


    ``` json

    {
        "status": false,
        "data": {},
        "error": [],
        "message": "unauthorized access"
    }

     ```

    Permission Denied


    ``` json

    {
        "status": false,
        "data": {},
        "error": [],
        "message": "unauthorized access: permission denied"
    }

     ```
servers:
  - url: https://api.platnova.com
    description: Production server
  - url: https://sandbox.api.platnova.co
    description: Development server
security:
  - apiKeyAuth: []
tags:
  - name: Customer
    description: Create and manage customers
  - name: Virtual Account
    description: Create and manage virtual accounts
  - name: Card
    description: Create and manage cards
  - name: Wallet
    description: List and manage wallets
  - name: Payment
    description: Send and verify payments
  - name: Transaction
    description: List transactions and generate receipts
  - name: Checkout
    description: Create and retrieve checkout sessions
  - name: Payment Link
    description: Create and manage payment links
  - name: Invoice
    description: Create and manage invoices
  - name: Bank
    description: Bank lists and account verification for bank transfers
  - name: Bills
    description: Betting wallet top-ups
paths:
  /v1/cards/{card_id}/terminate:
    parameters:
      - name: card_id
        in: path
        required: true
        description: unique id of the customers card
        example: 18ee492a-617c-4878-958a-2ee08dc20ff4
        schema:
          type: integer
    put:
      tags:
        - Card
      summary: Terminate card
      description: >-
        Close a card permanently. The card stops working at once and cannot be
        reactivated. Any balance on it is returned by the card issuer and
        credited back automatically, usually within a minute; `balance_refund`
        in the response says whether that is still to come. Terminating a card
        that is already terminated returns 200 with `already_terminated: true`,
        so the call is safe to retry.
      operationId: terminateCard
      parameters: []
      responses:
        '200':
          headers:
            Access-Control-Allow-Credentials:
              schema:
                type: boolean
              example: 'true'
            Access-Control-Allow-Headers:
              schema:
                type: string
              example: >-
                Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token,
                Authorization, accept, origin, Cache-Control, X-Requested-With,
                Api-Version, Platform
            Access-Control-Allow-Methods:
              schema:
                type: string
              example: POST, OPTIONS, GET, PUT, PATCH, DELETE
            Access-Control-Allow-Origin:
              schema:
                type: string
              example: '*'
            Content-Type:
              schema:
                type: string
              example: application/json
            X-Ratelimit-Limit:
              schema:
                type: integer
              example: '4'
            X-Ratelimit-Remaining:
              schema:
                type: integer
              example: '3'
            X-Ratelimit-Reset:
              schema:
                type: integer
              example: '1757349949'
            Date:
              schema:
                type: string
              example: Mon, 08 Sep 2025 16:44:51 GMT
            Content-Length:
              schema:
                type: integer
              example: '73'
          description: 200 - Success
          content:
            application/json:
              schema:
                type: object
                properties:
                  status:
                    type: boolean
                  data:
                    type: object
                    properties:
                      card_id:
                        type: string
                      status:
                        type: string
                        description: Always `cancelled`.
                      already_terminated:
                        type: boolean
                        description: >-
                          True when the card was already terminated before this
                          request.
                      currency:
                        type: string
                      balance:
                        type: number
                        description: The balance on the card when it was terminated.
                      balance_refund:
                        type: string
                        enum:
                          - none
                          - pending
                          - refunded
                        description: >-
                          `none`: nothing was on the card. `pending`: the
                          balance is on its way back and a
                          `card.termination_refund` webhook follows when it
                          lands. `refunded`: it was credited in this request.
                  error:
                    type: array
                    items: {}
                  message:
                    type: string
              example:
                status: true
                data:
                  card_id: 8c69ef84-891e-4a50-b03d-8e42d0733e8d
                  status: cancelled
                  already_terminated: false
                  currency: usd
                  balance: 0.58
                  balance_refund: pending
                error: []
                message: operation was successful
        '403':
          description: 403 - card_frozen_by_platnova
          content:
            application/json:
              example:
                status: false
                data:
                  code: card_frozen_by_platnova
                error:
                  - card_frozen_by_platnova
                message: >-
                  this card was frozen by Platnova and can't be unfrozen here.
                  Please contact support
        '404':
          description: 404 - card_not_found
          content:
            application/json:
              example:
                status: false
                data:
                  code: card_not_found
                error:
                  - card_not_found
                message: card not found
        '409':
          description: 409 - The card cannot be terminated in its current state
          content:
            application/json:
              examples:
                card_not_issued:
                  value:
                    status: false
                    data:
                      code: card_not_issued
                    error:
                      - card_not_issued
                    message: >-
                      this card was never issued, so there is nothing to
                      terminate
                card_movement_pending:
                  value:
                    status: false
                    data:
                      code: card_movement_pending
                    error:
                      - card_movement_pending
                    message: >-
                      a funding or withdrawal on this card is still processing;
                      terminate it once that has settled
                card_cannot_be_terminated:
                  value:
                    status: false
                    data:
                      code: card_cannot_be_terminated
                    error:
                      - card_cannot_be_terminated
                    message: >-
                      this card can't be terminated through the API. Please
                      contact support
components:
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: X-API-KEY
      description: API key for authentication.

````

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