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

# Retrieve a subscription



## OpenAPI

````yaml /api/openapi.yaml get /subscriptions/{subscription}
openapi: 3.1.0
info:
  title: Bouclay API
  version: 1.0.0
  summary: Integrator API for Bouclay subscriptions, invoices, payments, and webhooks.
  description: >
    Bouclay is managed recurring-billing infrastructure for African payment

    gateways. Integrators connect their own gateway account (Bachs, with Nomba,

    Paystack and Flutterwave in early access) and use this API to manage
    customers, catalog, subscriptions,

    entitlements, usage metering, invoices, payment-method checkout sessions,
    payments, and

    outbound event history.


    Bouclay never holds funds — every charge, refund, and payout happens on your

    own gateway account, with your own keys. Which gateway settles a given
    charge

    is Bouclay's concern, not yours: a stored card always charges through the

    gateway that issued its token.


    ## Early access


    Some of this API is documented ahead of its release, so you can build

    against it now. Those operations carry an **Early access** badge, and so

    do the request fields that depend on them (graduated, volume and package

    pricing, usage-based prices, usage thresholds). Until a feature is turned

    on for your account, its endpoints answer `404 not_found`, its fields are

    refused with a `422`, and a restricted key cannot be given its scopes.

    Ask us to turn it on. Nothing you already rely on changes when it is.
servers:
  - url: https://bouclay.com/api/v1
    description: Production
security:
  - SecretKeyAuth: []
tags:
  - name: Customers
  - name: Customer addresses
  - name: Payment methods
  - name: Entitlements
    description: >-
      Early access: answers `404 not_found` until it is turned on for your
      account.
  - name: Credits
    description: >-
      What a customer has left to spend. Money owed back to a customer is their
      balance, one per currency; their next invoice spends it after tax, like a
      payment, and collects the rest. Promotional credit you give is held in
      lots (credit grants), each with its own expiry; the next invoice spends it
      before tax, so it lowers the VAT like a discount.
  - name: Catalog
  - name: Payment links
    description: >-
      A shareable checkout page for one price, the same link a price's "Payment
      link" makes in the dashboard. Buyers enter their email and pay; a
      subscription price starts the subscription once paid.
  - name: Meters
    description: >-
      Early access: answers `404 not_found` until it is turned on for your
      account.
  - name: Usage
    description: >-
      Early access: answers `404 not_found` until it is turned on for your
      account.
  - name: Discounts
    description: >-
      Early access: answers `404 not_found` until it is turned on for your
      account.
  - name: Subscriptions
  - name: Invoices
  - name: Metrics
    description: >-
      Early access: answers `404 not_found` until it is turned on for your
      account. Revenue metrics measured from each subscription's monthly
      recurring amount (MRR). `active` and `past_due` subscriptions count;
      trials, pauses and metered usage do not. Amounts are major units, rates
      are percentages (105.25 means 105.25%), and currencies are never summed.
  - name: Credit notes
    description: >-
      A credit note corrects an issued invoice without changing it: "of this
      invoice, this much is no longer owed". Each one has its own number in an
      unbroken sequence (`{prefix}-CN-0001`) and never changes once issued. On
      an unpaid invoice the credit comes off `amountDue`; on a paid one it goes
      back to the customer, refunded to the card, added to the customer balance
      or settled outside Bouclay. What the customer balance paid of an invoice
      always goes back to the balance first. An invoice always satisfies
      `amountDue = total - amountPaid - amountCredited - balanceApplied`. Every
      refund also issues a credit note.
  - name: Payments
  - name: Refunds
    description: >-
      A refund goes back through the gateway that took the payment. Refund part
      of a payment and it stays `succeeded`; refund all of it and it becomes
      `refunded`.
  - name: Chargebacks
    description: >-
      A chargeback is a payment the customer's bank took back. Record one when
      your payment provider reports it, with the provider's dispute reference,
      then record how the dispute ended. While it is open, Bouclay doesn't
      charge or chase the subscription. A chargeback on a credit top-up takes
      back the unspent credit and its bonus; winning the dispute puts back
      exactly that. Uses the `refunds` scope.
  - name: Events
  - name: Checkout sessions
  - name: Portal sessions
  - name: Webhook endpoints
paths:
  /subscriptions/{subscription}:
    parameters:
      - $ref: '#/components/parameters/SubscriptionId'
    get:
      tags:
        - Subscriptions
      summary: Retrieve a subscription
      operationId: retrieveSubscription
      responses:
        '200':
          $ref: '#/components/responses/Subscription'
        '404':
          $ref: '#/components/responses/Error'
components:
  parameters:
    SubscriptionId:
      name: subscription
      in: path
      required: true
      schema:
        type: string
      example: sub_123
  responses:
    Subscription:
      description: Subscription response.
      content:
        application/json:
          schema:
            allOf:
              - $ref: '#/components/schemas/ResourceEnvelope'
              - type: object
                properties:
                  data:
                    $ref: '#/components/schemas/Subscription'
    Error:
      description: Structured API error.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
  schemas:
    ResourceEnvelope:
      type: object
      required:
        - data
        - meta
      properties:
        data:
          type: object
        meta:
          $ref: '#/components/schemas/Meta'
    Subscription:
      type: object
      properties:
        id:
          type: string
        planId:
          type:
            - string
            - 'null'
          description: >-
            The base plan, the one its live plan items are on. Kept in step once
            each plan change, retirement or price swap commits; a canceled
            subscription keeps the plan it was on.
        status:
          type: string
        pauseReason:
          description: >-
            Why a paused subscription is paused. `payment_overdue` means dunning
            suspended it: access is off, the invoice stays open, and paying it
            resumes the subscription. Voiding it or marking it uncollectible
            turns the suspension into `requested`. `plan_retired` means its plan
            was discontinued with nothing in its place: move it to another plan,
            then resume it.
          type:
            - string
            - 'null'
          enum:
            - requested
            - payment_overdue
            - plan_retired
            - null
        pauseResumesAt:
          description: When a paused subscription resumes on its own, else null.
          type:
            - string
            - 'null'
          format: date-time
        currency:
          type: string
        collectionMode:
          type: string
          enum:
            - automatic
            - manual
        daysUntilDue:
          type:
            - integer
            - 'null'
          description: >-
            The subscription's own payment terms in days; null means the
            business's payment terms apply.
        reference:
          type:
            - string
            - 'null'
          description: The buyer's purchase order number, printed on its invoices.
        invoicingThreshold:
          $ref: '#/components/schemas/MajorAmount'
        minimumCommitment:
          $ref: '#/components/schemas/MajorAmount'
          description: >-
            The minimum commitment in force: the least the subscription bills
            each period, in major units. Null when it has none. A change is sent
            as `subscription.updated`.
        spendingCap:
          description: >-
            The spending cap in force, or null. A change is sent as
            `subscription.updated`.
          oneOf:
            - $ref: '#/components/schemas/SpendingCap'
            - type: 'null'
        trialEndsAt:
          type:
            - string
            - 'null'
          format: date-time
        currentPeriodStart:
          type:
            - string
            - 'null'
          format: date-time
        currentPeriodEnd:
          type:
            - string
            - 'null'
          format: date-time
        canceledAt:
          type:
            - string
            - 'null'
          format: date-time
        endsAt:
          type:
            - string
            - 'null'
          format: date-time
        cancellationDetails:
          description: >-
            Why it was cancelled, while it is cancelling or canceled. Null
            otherwise, including after the cancel is undone.
          type:
            - object
            - 'null'
          properties:
            reason:
              type:
                - string
                - 'null'
            comment:
              type:
                - string
                - 'null'
            source:
              type: string
              enum:
                - portal
                - dashboard
                - api
        customer:
          $ref: '#/components/schemas/NestedCustomer'
        discount:
          description: >-
            The discount still taking money off its invoices, or null (none, or
            used up). `remainingIntervals` is how many more invoices it applies
            to; null means for as long as the subscription runs.
          type:
            - object
            - 'null'
          properties:
            id:
              type: string
            code:
              type:
                - string
                - 'null'
            remainingIntervals:
              type:
                - integer
                - 'null'
        createdAt:
          type:
            - string
            - 'null'
          format: date-time
        trialEndBehavior:
          type:
            - string
            - 'null'
        paymentMethod:
          type:
            - object
            - 'null'
          properties:
            id:
              type: string
        items:
          type: array
          items:
            $ref: '#/components/schemas/SubscriptionItem'
        scheduledChanges:
          type: array
          description: >-
            Changes booked for a later date, usually the next renewal, each with
            what it changes. Fields that don't apply to an action are left out.
          items:
            type: object
            properties:
              action:
                type: string
                enum:
                  - cancel
                  - pause
                  - resume
                  - update
                  - change_plan
                  - add_charge
                  - end_charge
              effectiveAt:
                type:
                  - string
                  - 'null'
                format: date-time
              itemId:
                description: '`update`: the item that changes.'
                type: string
                example: si_123
              quantity:
                description: >-
                  `update`: the item's new quantity, or null when it keeps its
                  own.
                type:
                  - integer
                  - 'null'
                example: 2
              priceId:
                description: '`update`: the item''s new price, or null when it keeps its own.'
                type:
                  - string
                  - 'null'
              remove:
                description: '`update`: true when the item is removed.'
                type: boolean
              planId:
                description: '`change_plan`: the plan the subscription moves onto.'
                type: string
              chargeId:
                description: >-
                  `add_charge` and `end_charge`: the plan's charge that starts
                  or ends.
                type: string
              resumesAt:
                description: '`pause`: when the subscription comes back on its own, or null.'
                type:
                  - string
                  - 'null'
                format: date-time
        sharedMeters:
          type: array
          description: >-
            Meters another of the customer's live subscriptions bills too. Meter
            events carry no subscription, so each such event is billed on both.
            A new overlap is refused (`meter_billed_elsewhere`); this lists one
            that slipped through, such as a payment link paid while another
            subscription started. Empty when there is none.
          items:
            type: object
            properties:
              meterId:
                type: string
              meterName:
                type: string
              subscriptionIds:
                type: array
                items:
                  type: string
    ErrorResponse:
      type: object
      required:
        - error
        - meta
      properties:
        error:
          type: object
          required:
            - type
            - code
            - detail
          properties:
            type:
              type: string
              enum:
                - request_error
                - api_error
              description: >-
                `api_error` with code `internal_error` (HTTP 500) means the
                fault is ours: retry with the same Idempotency-Key.
              example: request_error
            code:
              type: string
              enum:
                - authentication_failed
                - permission_denied
                - invalid_field
                - invalid_cursor
                - idempotency_conflict
                - meter_not_found
                - meter_archived
                - customer_not_found
                - timestamp_in_future
                - usage_period_closed
                - subscription_paused
                - missing_property
                - invalid_value
                - conflict
                - subscription_suspended
                - no_upcoming_invoice
                - not_found
                - request_error
                - internal_error
            detail:
              type: string
            errors:
              type: array
              items:
                type: object
                required:
                  - field
                  - message
                properties:
                  field:
                    type: string
                  message:
                    type: string
        meta:
          $ref: '#/components/schemas/Meta'
    Meta:
      type: object
      required:
        - requestId
      properties:
        requestId:
          type: string
          example: req_550e8400-e29b-41d4-a716-446655440000
    MajorAmount:
      type:
        - number
        - 'null'
      minimum: 0
      description: Major currency units. For example, 15000 means NGN 15,000.
    SpendingCap:
      type: object
      properties:
        amount:
          $ref: '#/components/schemas/MajorAmount'
        covers:
          type: string
          enum:
            - usage
            - all
        behavior:
          type: string
          enum:
            - cap
            - warn
        warnAt:
          type: array
          items:
            type: integer
        since:
          type: string
          format: date-time
    NestedCustomer:
      type: object
      properties:
        id:
          type: string
        email:
          type: string
          format: email
        name:
          type:
            - string
            - 'null'
        taxId:
          description: >-
            On an invoice, the customer's TIN as it was when the invoice was
            issued.
          type:
            - string
            - 'null'
    SubscriptionItem:
      type: object
      properties:
        id:
          type: string
        productId:
          type: string
        planId:
          type: string
        chargeId:
          type: string
          description: Which of the plan's charges the item bills.
        priceId:
          type: string
        quantity:
          type: integer
        status:
          type: string
  securitySchemes:
    SecretKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: '{sk|rk}_{mode}_{random}'
      description: >
        Use a Bouclay secret key (`sk_test_...`, `sk_live_...`) or restricted
        key

        (`rk_test_...`, `rk_live_...`).


        A secret key can call every endpoint. A restricted key can only call the

        endpoints its scopes cover. A scope is `{resource}:{access}`, for
        example

        `customers:read` or `refunds:write`, and write includes read. `GET`

        requests need read access and everything else needs write, except

        `POST /subscriptions/{id}/items/{item}/preview`, which only needs

        `subscriptions:read`. A request outside the key's scopes gets `403

        permission_denied` naming the missing scope, and its `Idempotency-Key`

        is not used up.


        | Resource | Endpoints | Access |

        | --- | --- | --- |

        | `customers` | customers, their addresses and payment methods | read,
        write |

        | `entitlements` | `/customers/{id}/entitlements` | read |

        | `credits` | `/customers/{id}/credit-balance`, credit purchases, credit
        grants, auto-reloads, credit holds (committing one records its usage) |
        read, write |

        | `catalog` | products, plans, prices | read, write |

        | `meters` | meters | read, write |

        | `usage` | meter events, `/customers/{id}/usage` | read, write |

        | `discounts` | discounts | read |

        | `subscriptions` | subscriptions | read, write |

        | `invoices` | invoices | read, write |

        | `credit_notes` | credit notes, `POST /invoices/{id}/credit-notes` (a
        refund to the card also needs `refunds:write`) | read, write |

        | `payments` | payments | read |

        | `refunds` | refunds, `POST /payments/{id}/refunds`, chargebacks and
        their outcome | read, write |

        | `checkout_sessions` | checkout sessions | read, write |

        | `portal_sessions` | portal sessions | write |

        | `events` | events | read |

        | `webhook_endpoints` | webhook endpoints | read, write |

        | `metrics` | metrics | read |


        Publishable keys (`pk_...`) are rejected by server-side API endpoints. A

        key's mode scopes what it can see and charge: a test key can never reach

        a live card.

````

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