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

> ## Agent Instructions
> Money amounts are always major-unit decimal strings (e.g. "1000.00"), never floats and never minor units, in every request, response, and webhook payload.
> Authentication is OAuth 2.0 client credentials: exchange the Client ID and Client Secret at the Token URL for a 24-hour JWT and cache it; do not request a token per call.
> Set a unique clientRef on every money-moving request; it is the idempotency key, and retries return the original resource.
> Quotes are single-use, intent-locked, and expire fast: always read expiresAt, consume the quote with the executor matching its intent, and re-quote on expiry instead of retrying.
> Prefer webhooks over polling for payout, order, application, and virtual-account status tracking.
> Use the sandbox (api.sandbox.zuba.com) with its deterministic magic values before touching production.

# Record that the account owner accepted one of the account terms

> Records the owner’s acceptance of one document from the terms an account would be opened under. The documents, their `slug`, the `version` to acknowledge and the exact wording each acceptance stands for come from `GET /v1/virtual-accounts/requirements`, whose `disclosure.acknowledgement` requirement lists every outstanding document with this call as its `acknowledgePath`. The acceptance is recorded against the owner’s application before or after its approval. Idempotent per document; acknowledging again at a newer version updates the record in place. Acknowledging with an API key attests that the owner accepted in your own flow, so `attestation` is required there and carries the evidence (when they accepted, from which IP and user agent, and who signed). A dashboard session records the signed-in user’s own click and sends no attestation.



## OpenAPI

````yaml /openapi.json post /v2/applications/{applicationId}/disclosures/{slug}/acknowledge
openapi: 3.0.0
info:
  contact: {}
  description: >-
    Comprehensive payment platform API supporting fiat and crypto payments,
    currency conversion, and compliance management
  title: Zuba Payment Platform API
  version: '1.0'
servers: []
security: []
tags:
  - description: Manage M2M API keys and credentials
    name: API Keys
  - description: Per-country bank directories and bank-account enquiries
    name: Banks
  - description: Internal ledger accounts and transactions
    name: Ledger
  - description: Handle incoming payments and deposits
    name: Pay-ins
  - description: Manage payouts, beneficiaries, and SEPA transfers
    name: Payouts
  - description: Manage outbound webhook endpoints and deliveries
    name: Webhooks
paths:
  /v2/applications/{applicationId}/disclosures/{slug}/acknowledge:
    post:
      tags:
        - Applications (v2)
      summary: Record that the account owner accepted one of the account terms
      description: >-
        Records the owner’s acceptance of one document from the terms an account
        would be opened under. The documents, their `slug`, the `version` to
        acknowledge and the exact wording each acceptance stands for come from
        `GET /v1/virtual-accounts/requirements`, whose
        `disclosure.acknowledgement` requirement lists every outstanding
        document with this call as its `acknowledgePath`. The acceptance is
        recorded against the owner’s application before or after its approval.
        Idempotent per document; acknowledging again at a newer version updates
        the record in place. Acknowledging with an API key attests that the
        owner accepted in your own flow, so `attestation` is required there and
        carries the evidence (when they accepted, from which IP and user agent,
        and who signed). A dashboard session records the signed-in user’s own
        click and sends no attestation.
      operationId: DisclosureAcknowledgementV2Controller_acknowledge
      parameters:
        - in: path
          name: applicationId
          required: true
          schema:
            format: uuid
            type: string
        - description: The document’s `slug` as the requirements response names it.
          in: path
          name: slug
          required: true
          schema:
            example: terms-of-service
            type: string
        - description: >-
            Optional. Names an owned sub-account (UUID); when present, the
            application must belong to it. Omit to act on any application in
            your workspace. Naming an account this key does not own returns 403
            not_account_owner.
          in: header
          name: Zuba-Account-Id
          required: false
          schema:
            format: uuid
            type: string
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/AcknowledgeDisclosureDto'
        required: true
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AcknowledgeResponseDto'
          description: ''
        '400':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GenericErrorResponseDto'
          description: >-
            Validation failure, attestation_required (acknowledging with an API
            key without the acceptance evidence), or attestation_not_accepted (a
            dashboard session sending one)
        '401':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GenericErrorResponseDto'
          description: Unauthorized
        '403':
          content:
            application/json:
              schema:
                anyOf:
                  - $ref: '#/components/schemas/GenericErrorResponseDto'
          description: >-
            not_account_owner (Zuba-Account-Id does not name an account you
            own), the API key is missing the create:disclosures scope, or
            Insufficient role (a dashboard session whose workspace role is
            viewer).
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GenericErrorResponseDto'
          description: >-
            No application with this id is visible to you, or
            disclosure_not_found (none of the terms this application can be
            opened under carries this slug)
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GenericErrorResponseDto'
          description: >-
            documentVersion is not the version in force (re-read the
            requirements and retry at the version they name), or
            application_rejected (a rejected application accepts no terms)
      security:
        - bearer: []
components:
  schemas:
    AcknowledgeDisclosureDto:
      properties:
        attestation:
          allOf:
            - $ref: '#/components/schemas/DisclosureAttestationDto'
          description: >-
            Required when acknowledging with an API key on an owner's behalf.
            Omitted by a dashboard session, whose acknowledgment is the
            signed-in user's own.
        documentVersion:
          example: 2026.08.07
          type: string
      required:
        - documentVersion
      type: object
    AcknowledgeResponseDto:
      properties:
        acknowledgedAt:
          example: '2026-08-07T10:22:33.123Z'
          type: string
        acknowledgedByActorType:
          description: >-
            Which surface recorded this acknowledgment. An `api_key` row always
            carries a complete `attestation`; a `dashboard_user` row never does,
            because the signed-in click is itself the evidence. null names a row
            that asserts neither, so a missing `attestation` is never ambiguous.
          enum:
            - dashboard_user
            - api_key
          nullable: true
          type: string
        attestation:
          allOf:
            - $ref: '#/components/schemas/DisclosureAttestationDto'
          description: >-
            The acceptance evidence recorded with this acknowledgment, or null
            when the owner acknowledged in the Zuba dashboard themselves.
          nullable: true
          type: object
        id:
          description: UUID of the ack row.
          type: string
        slug:
          type: string
        version:
          type: string
      required:
        - id
        - acknowledgedAt
        - slug
        - version
        - acknowledgedByActorType
      type: object
    GenericErrorResponseDto:
      properties:
        error:
          description: Error type identifier
          example: BAD_REQUEST
          type: string
        message:
          description: Error message
          example: Bad Request
          type: string
        path:
          description: Request path that generated the error
          example: /v1/resource
          type: string
        statusCode:
          description: HTTP status code
          example: 400
          type: number
        timestamp:
          description: ISO timestamp when the error occurred
          example: '2024-01-15T10:30:00.000Z'
          type: string
      required:
        - statusCode
        - message
        - error
        - timestamp
        - path
      type: object
    DisclosureAttestationDto:
      properties:
        acceptedAt:
          description: >-
            When the owner accepted, as observed by the platform. Distinct from
            the moment Zuba recorded the acknowledgment, and never later than it
            beyond a five-minute clock-skew tolerance.
          example: '2026-08-24T10:22:33.000Z'
          format: date-time
          type: string
        ip:
          description: IP address the owner accepted from (IPv4 or IPv6).
          example: 203.0.113.42
          type: string
        signerEmail:
          description: Email of the person who accepted.
          example: ada@example.com
          type: string
        signerName:
          description: Name of the person who accepted.
          example: Ada Lovelace
          type: string
        userAgent:
          description: User agent the owner accepted from.
          example: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)
          type: string
      required:
        - acceptedAt
        - ip
        - userAgent
        - signerName
        - signerEmail
      type: object
  securitySchemes:
    bearer:
      bearerFormat: JWT
      description: Enter Auth0 JWT token
      scheme: bearer
      type: http

````

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