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

# Remove signers from a signer group, with signatures

> Removes members from the signer group with signatures from the group's
governance, which policy-engine verifies before anything changes. The
group's `version` increases by 1.

This is the signed counterpart of
`DELETE /signer-groups/{signer_group_id}/signers/{signer_id}`. A client
under governance enforcement, or a group with governance settings, can
remove members only this way. An `operate` API key of a client under
governance enforcement may call it, since the signatures carry the
authority.




## OpenAPI

````yaml /openapi.yaml post /signer-groups/{signer_group_id}/signer-removals
openapi: 3.0.3
info:
  title: Dakota Platform API
  version: 1.0.0
  description: >-
    Combined API specification for Dakota Platform services:

    - Issuance API: Asset minting and burning operations

    - Onboarding API: Know Your Business/Customer verification

    - On/Off Ramp API: Managing on-ramp and off-ramp accounts

    - Recipients API: Managing destinations for KYB'd entities

    - Transactions API: Viewing transaction history across platform operations


    ## Authentication and API Headers


    All API endpoints require the following headers:


    - `X-Idempotency-Key`: Required for all POST endpoints to ensure request
    idempotency

    - `x-api-key`: Required for authentication across all endpoints


    Note: On /applications endpoints you need a token for authentication instead
    of a x-api-key

    - `x-application-token`: Required for authentication on public /applications
    endpoints (alternative to `x-api-key` where documented)



    ## Rate Limits


    Requests are rate limited per API key. Every response includes the following
    headers:


    | Header | Description |

    | --- | --- |

    | `X-RateLimit-Limit` | Maximum requests allowed in the current one-minute
    window. |

    | `X-RateLimit-Remaining` | Requests remaining in the current window. |

    | `X-RateLimit-Reset` | Absolute Unix timestamp (seconds since epoch) when
    the current rate-limit window resets. |


    When a request is throttled (`429`), responses also include `Retry-After`
    with seconds to wait before retrying.
servers:
  - url: https://api.platform.dakota.xyz
    description: Production environment
  - url: https://api.platform.sandbox.dakota.xyz
    description: Sandbox — safe for testing with simulated data
security:
  - ApiKeyAuth: []
tags:
  - name: Agentic Payments
    x-beta: true
    description: >-
      Beta — agent-driven payments: provision agents, draft and approve spending
      mandates, accept reviewed instructions, and manage scheduled payments.


      **Prerequisites:** Customer onboarded; signer groups attached for
      recognition.

      **Related:** Wallets, Signer Groups, Transactions
  - name: Mandates
    x-beta: true
    description: >-
      Beta — spending mandates: signed, signer-bound authorizations governing
      what may be spent, approved or cancelled by a second recognized signer (§8
      — the dual-control rule that every mandate mutation must be signed by a
      recognized signer OTHER than the bound one). Independent of agents and
      scheduled payments.


      **Prerequisites:** Signer groups attached for recognition.

      **Related:** Signer Groups, Transactions
  - name: Insights
    x-beta: true
    description: >-
      Beta — read-only insight: a deterministic report over a customer's agentic
      activity (funding balances, upcoming obligations, failures, mandate
      headroom and expiry), or — via `GET /insights` — over the whole client's
      book, with portfolio KPIs, daily series and a per-customer roll-up. Never
      moves money, never creates or changes anything.


      **Prerequisites:** Customer onboarded; insight is computed from the
      customer's scheduled payments, mandates, and wallets.

      **Related:** Agentic Payments, Mandates
  - name: Customers
    description: >-
      Manage customer entities representing businesses and organizations
      onboarded to Dakota.


      **Prerequisites:** Complete KYB via Onboarding endpoints before initiating
      money movement.

      **Related:** Onboarding, Recipients, Transactions, Accounts, Wallets
  - name: Wallets
    description: >-
      Manage wallets, balances, and wallet-to-signer-group relationships for
      custody and movement controls.


      **Prerequisites:** Customer must exist. Configure signer groups before
      policy-enforced workflows.

      **Related:** Signer Groups, Policies, Transactions, Customers
  - name: Transactions
    description: >-
      Create, cancel, and retrieve transaction records across account and wallet
      flows.


      **Prerequisites:** Accounts or destinations must be configured based on
      flow type.

      **Related:** Accounts, Recipients, Policies, Events
  - name: Recipients
    description: >-
      Manage recipient entities and destination rails used by customers for
      payouts and transfers.


      **Prerequisites:** Customer must be onboarded and active.

      **Related:** Customers, Transactions, Accounts, Onboarding
  - name: Cards
    description: >-
      Issue and manage cardholders and cards, and follow card transactions.
      Every change is also delivered as a webhook event.


      **Prerequisites:** Customer must be onboarded and the cards capability
      must be available.

      **Related:** Customers, Wallets, Events


      ### Webhook event catalog (v1)


      Every card-family event a client can subscribe to, in one place:


      | Event | Fires when |

      | -- | -- |

      | `cardholder.created` | A cardholder is created. |

      | `cardholder.updated` | Any cardholder change, including every
      review-status transition and deletion (`status: closed`). |

      | `cardholder.information_requested` | A reviewer asks for more
      information; the payload lists the open requirements. |

      | `card.created` | A card is created. |

      | `card.updated` | Any card change: status, spend limit, last4, freeze
      sources. A close arrives here with `status: closed`. |

      | `card_transaction.created` | The first event for a transaction, normally
      an authorization (`status: authorized`) placing a hold. A declined
      authorization also arrives here, with `status: declined`. |

      | `card_transaction.updated` | Every later change to the same transaction
      (see below). |

      | `wallet.card_enablement.completed` | A wallet's card-settlement
      enablement became active. |


      **Card event ordering.** `card.created` and `card.updated` carry the card
      as it stands after

      the change, including `version` and `freeze_sources` (always an array,
      empty when nothing

      holds the card). `version` is strictly increasing per card and matches the
      `version` on the

      card resource. Deliveries can arrive out of order, so keep the highest
      `version` you have

      applied for each card and drop any event whose `version` is not greater
      than it.


      **One transaction stream.** Holds, releases, partial clearings,
      settlement, returns,

      disputes and force posts are not separate event types. They are `status`
      transitions on

      the transaction, delivered as `card_transaction.updated` with the same
      payload shape as

      `card_transaction.created`:


      | What happened | `status` on the event |

      | -- | -- |

      | Transaction known before its first authorization event | `pending` (on
      `card_transaction.created`) |

      | Hold placed (authorization) | `authorized` (on
      `card_transaction.created`, or `card_transaction.updated` after a
      `pending` start) |

      | Hold released without clearing (merchant, issuer or network reversal) |
      `auth_reversed` |

      | Hold expired unused | `expired` |

      | Part of the hold settled | `partially_cleared` (with the new
      `cleared_amount`) |

      | Fully settled | `cleared` |

      | Settled with no prior hold | `force_posted` |

      | Merchant refund | `returned`, usually on a new card transaction for the
      refund while the original purchase stays `cleared`. A refund can also land
      on the purchase's own transaction, which keeps its purchase status until
      the refunds cover everything that cleared and nothing authorized is left
      to clear. A transaction carries a refund whenever `refund_state` has a
      value, whatever its `status`. `returned_amount` is how much was refunded.
      The network returned the money; read `refund_state` for whether it reached
      the customer's wallet: `pending` while owed, then `paid`; `reversed` when
      every refund was cancelled before payout; `failed` when a payout failed.
      `returned` alone is not proof of payout. |

      | Merchant refund on its own transaction, fully reversed before it is paid
      out | `auth_reversed` on the refund's card transaction, with
      `refund_state: reversed`. The refund is withdrawn; `refund_state` is what
      tells it from a released hold. |

      | Chargeback opened | `disputed` (reserved; not emitted yet) |

      | Authorization refused | `declined` (on `card_transaction.created`, or
      `card_transaction.updated` when the transaction already exists). Moves no
      money; read `decline_reason` and `decline_code` for why. |


      `outstanding_amount` is the part of `cleared_amount` that no authorization
      covered, less any refunds: non-zero after a force post or an over-capture.


      **Naming.** A dotted segment names a sub-resource of the resource before
      it, so

      `wallet.card_enablement.*` is a wallet's card enablement.
      `card_transaction.*` carries an

      underscore because the resource is `card_transactions`, a top-level
      resource, not a

      sub-resource of a card. It is not a typo, and there is no
      `card.transaction.*` family, and

      no separate settlement event: settlement is a `status` on
      `card_transaction.updated`.


      **Two states on a dispute report, and neither derives from the other.**
      `filing_state`

      is how far the automated filing with the provider has got. `state` is the
      Dakota operator

      workflow, where `filed_at_vendor` still means a person filed by hand. A
      successful

      automated filing does not move `state`. Read the one you mean.
  - name: Accounts
    description: >-
      Manage account resources used for onramp, offramp, and swap operations.


      **Prerequisites:** Customer must be created and network/asset constraints
      must be known.

      **Related:** Customers, Transactions, Auto Transactions, Info
  - name: Auto Transactions
    description: >-
      Manage automated transaction configurations and execution history for
      account automation workflows.


      **Prerequisites:** Source account must exist and be configured for
      automation.

      **Related:** Accounts, Transactions, Events
  - name: Onboarding
    description: >-
      Manage KYB/KYC onboarding lifecycle, application documents, attestations,
      and verification steps.


      **Prerequisites:** Customer context and required entity/application
      metadata.

      **Related:** Customers, Exceptions, Recipients, Transactions
  - name: Policies
    description: >-
      Define and manage policy objects and rules used for transaction governance
      and risk controls.


      **Prerequisites:** Wallet and signer group resources should be configured
      for enforcement scenarios.

      **Related:** Wallets, Signer Groups, Transactions
  - name: Signer Groups
    description: >-
      Manage signer groups and signer assignments for multi-party authorization
      models.


      **Prerequisites:** Wallets should exist before linking signer groups.

      **Related:** Wallets, Policies, Transactions
  - name: Authentication
    description: >-
      Manage API authentication credentials and key lifecycle for platform
      access.


      **Prerequisites:** Client organization must be provisioned.

      **Related:** Users, Info
  - name: Users
    description: >-
      Manage client users, roles, and identity metadata for platform access
      control.


      **Prerequisites:** Auth credentials and client context must be
      established.

      **Related:** Authentication
  - name: Webhooks
    description: >-
      Manage outbound webhook targets and delivery configuration for event
      notifications.


      **Prerequisites:** Subscriber endpoint must be reachable and secured.

      **Related:** Events, Authentication
  - name: Payouts
    description: >-
      Manage where Dakota sends your accrued developer-fee payouts.


      **Prerequisites:** Auth credentials and client context must be
      established.

      **Related:** Events
  - name: RD Marketing Fee
    description: >-
      Everything behind your RD marketing fee: read what a month came to,
      declare the wallets you hold outside Dakota so the RD in them counts, and
      say where the fee should be sent.


      **Prerequisites:** Client must be in the RD marketing-fee programme. A
      month is readable once it has closed.

      **Related:** Wallets, Events
  - name: Self Serve
    description: >-
      Buy and track prepaid credits, and read the tiers and pricing they are
      sold at.


      **Prerequisites:** Auth credentials and client context must be
      established.

      **Related:** Billing
  - name: Events
    description: >-
      Retrieve event records emitted by platform operations for audit and
      troubleshooting.


      **Prerequisites:** Requesting client must have access to referenced
      resources.

      **Related:** Webhooks, Transactions, Onboarding
  - name: Info
    description: >-
      Read platform capability metadata, such as supported rails, networks, and
      assets.

      These operations are served under `/capabilities/*` - `GET
      /capabilities/countries`

      and `GET /capabilities/networks`. The tag name does not appear in the
      request paths.


      **Prerequisites:** Valid authentication headers.

      **Related:** Accounts, Transactions
  - name: Sandbox
    description: >-
      Trigger sandbox-only simulation endpoints for safe end-to-end integration
      testing with synthetic data. The sandbox host
      (`https://api.platform.sandbox.dakota.xyz`) also accepts a family of
      `X-Sandbox-*` request headers on most write endpoints (`Customers`,
      `Accounts`, `Transactions`, simulate endpoints) that let integrators drive
      deterministic failure modes — pick a preset via `X-Sandbox-Scenario`, or
      compose a custom one with
      `X-Sandbox-Error-Step`/`X-Sandbox-Error-Status`/`X-Sandbox-Error-Message`.
      `X-Sandbox-Instant-Completion` collapses async flows to a single
      synchronous step, and `X-Sandbox-Skip-Auto-Approval` keeps newly created
      KYB applications in `pending` for manual-review testing. All `X-Sandbox-*`
      headers are ignored in production.


      **Prerequisites:** Sandbox environment and test customer data.

      **Related:** Customers, Accounts, Transactions, Onboarding
  - name: Legal
    description: |-
      The legal documents customers accept — terms of service, privacy policy,
      e-sign notice, and partner agreements.

      Dakota publishes these here, and this is the authoritative source: the
      hosted onboarding flow, the dakota.xyz website, and your own integration
      all read the same revisions. Present the current revision to your customer
      before capturing their acceptance so the record reflects the text they
      actually saw.
paths:
  /signer-groups/{signer_group_id}/signer-removals:
    post:
      tags:
        - Signer Groups
      summary: Remove signers from a signer group, with signatures
      description: |
        Removes members from the signer group with signatures from the group's
        governance, which policy-engine verifies before anything changes. The
        group's `version` increases by 1.

        This is the signed counterpart of
        `DELETE /signer-groups/{signer_group_id}/signers/{signer_id}`. A client
        under governance enforcement, or a group with governance settings, can
        remove members only this way. An `operate` API key of a client under
        governance enforcement may call it, since the signatures carry the
        authority.
      operationId: removeSignerGroupSigners
      parameters:
        - name: signer_group_id
          in: path
          required: true
          description: Signer Group ID
          schema:
            $ref: '#/components/schemas/KSUID'
        - $ref: '#/components/parameters/IdempotencyKeyHeader'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/RemoveSignerGroupSignersRequest'
            example:
              members_to_remove:
                - MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE...
              signer_group_version: 3
              signatures:
                - MEUCIQDx...base64
      responses:
        '200':
          description: Signers removed
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SignerGroup'
              example:
                id: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
                client_id: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
                name: My Wallet
                members:
                  - id: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
                    client_id: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
                    name: Marc
                    public_key: string
                    key_type: ES256
                version: 4
                effective_governance_threshold: 1
        '400':
          description: Bad request - invalid input data
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
        '401':
          description: Unauthorized
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
        '403':
          description: >-
            Forbidden, or `insufficient_endorsements` - the signatures do not
            meet the group's governance quorum
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
              example:
                type: >-
                  https://docs.dakota.xyz/api-reference/errors#insufficient-endorsements
                title: Insufficient Endorsements
                status: 403
                detail: >-
                  insufficient endorsements for signer group
                  2N4YkLb7wQ9xT3mVd8sRk2PzHcA: have 1, need 2
                instance: >-
                  https://api.platform.dakota.xyz/signer-groups/example-id/signer-removals
                request_id: req_01hzy6y7v8w9x0y1z2a3b4c5d6
                reason: insufficient_endorsements
                code: insufficient_endorsements
                params:
                  signer_group_id: 2N4YkLb7wQ9xT3mVd8sRk2PzHcA
                  have: '1'
                  need: '2'
        '404':
          description: Signer Group not found
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
        '409':
          description: >-
            `stale_signer_group_version` - the group changed since the
            signatures were made
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
              example:
                type: >-
                  https://docs.dakota.xyz/api-reference/errors#stale-signer-group-version
                title: Stale Signer Group Version
                status: 409
                detail: >-
                  The signer group changed since the signatures were made. Read
                  the group's version and sign again.
                instance: >-
                  https://api.platform.dakota.xyz/signer-groups/example-id/signer-removals
                request_id: req_01hzy6y7v8w9x0y1z2a3b4c5d6
                reason: stale_signer_group_version
                code: stale_signer_group_version
        '422':
          description: >-
            `below_threshold` - the removal would leave the group below a
            threshold it must keep (at least one member, its governance quorum,
            or a governed group's threshold). A policy's approval threshold does
            not block a removal; a policy left unmeetable denies sends until a
            member is added.
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
              example:
                type: https://docs.dakota.xyz/api-reference/errors#below-threshold
                title: Below Threshold
                status: 422
                detail: >-
                  The removal would leave the group below a threshold it must
                  keep.
                instance: >-
                  https://api.platform.dakota.xyz/signer-groups/example-id/signer-removals
                request_id: req_01hzy6y7v8w9x0y1z2a3b4c5d6
                reason: below_threshold
                code: below_threshold
        '500':
          description: Internal server error
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
        '503':
          description: Service unavailable
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
      externalDocs:
        description: Read full guide in docs
        url: >-
          https://docs.dakota.xyz/api-reference/signer-groups/remove-signers-from-a-signer-group-with-signatures
components:
  schemas:
    KSUID:
      type: string
      title: KSUID
      description: >-
        KSUID is a 27-character globally unique ID that combines a timestamp
        with a random component. Used for all entity identifiers in the Dakota
        platform.
      pattern: ^[0-9A-Za-z]{27}$
      minLength: 27
      maxLength: 27
      example: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
    RemoveSignerGroupSignersRequest:
      type: object
      description: |
        A signed removal of members from a signer group. Policy-engine verifies
        the signatures against the group's governance (the members of its
        governing group, `governance_signer_group_id`, else the group itself;
        at least `effective_governance_threshold` distinct members, never
        counting payment-agent or card-settlement keys) and refuses a removal
        that would leave the group below a threshold it must keep.
      required:
        - members_to_remove
        - signer_group_version
        - signatures
      properties:
        members_to_remove:
          type: array
          minItems: 1
          maxItems: 100
          description: Public keys of the members to remove, as the group lists them.
          items:
            type: string
            example: MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE...
        signer_group_version:
          type: integer
          format: int64
          minimum: 0
          description: The group's `version` the signatures were made over.
          example: 3
        signatures:
          type: array
          minItems: 1
          maxItems: 100
          description: >
            Signatures over the canonical intent, each base64-encoded, in the

            format the endorsed policy routes use (ES256 ASN.1 DER, or a

            WebAuthn assertion whose challenge is the canonical intent).

            The canonical intent is

            `{"group_id":"<id>","idempotency_key":"<X-Idempotency-Key>","members_to_remove":["<public_key>"],"signer_group_version":<version>,"type":"remove_signers_from_group"}`,

            with `members_to_remove` in the order sent.
          items:
            type: string
            example: MEUCIQDx...base64
    SignerGroup:
      type: object
      description: Group of signers that dictates who can sign transactions for a wallet
      required:
        - id
        - client_id
        - name
        - members
      properties:
        id:
          $ref: '#/components/schemas/KSUID'
        client_id:
          $ref: '#/components/schemas/KSUID'
        name:
          type: string
          description: The wallet name
          example: My Wallet
        members:
          type: array
          description: Members that make up the signer group
          items:
            $ref: '#/components/schemas/Signer'
        removed_members:
          type: array
          description: |
            Signers previously in this group that have since been removed.
            Populated only when the request sets `include_removed=true`; each
            entry carries its `removed_at` timestamp. Omitted otherwise.
          items:
            $ref: '#/components/schemas/Signer'
        version:
          type: integer
          format: int64
          description: |
            The group's version. It increases by 1 with every membership or
            governance change. Endorsements of a membership or governance
            change sign over it as `signer_group_version`, so a signature made
            before a change cannot be replayed after it.
          example: 3
        governance_threshold:
          type: integer
          format: int32
          nullable: true
          description: >-
            The explicit number of distinct endorsers a governance change of the
            group needs, or null for the default.
          example: 2
        effective_governance_threshold:
          type: integer
          format: int32
          description: |
            The number of distinct endorsers a governance change of the group
            needs now: `governance_threshold` when set, as set; else the
            default: 2 when the client has governance enforcement on and the
            governing group (the group itself when it governs itself) has 3 or
            more members, else 1, capped at the governing group's members that
            can endorse and never below 1. Keys of payment agents and card
            settlement signers are members for spending only: they never
            endorse governance changes.
          example: 2
        governance_signer_group_id:
          type: string
          nullable: true
          description: >-
            The signer group whose members endorse governance changes of this
            group instead of its own members, or null when the group governs
            itself.
          example: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
    ProblemDetails:
      type: object
      required:
        - type
        - title
        - status
      description: |
        Error response following RFC 9457 Problem Details.
        Public API error responses use this format.
      example:
        type: https://docs.dakota.xyz/api-reference/errors#not-found
        title: Customer Not Found
        status: 404
        detail: Customer cst_2abc123 was not found in your organization.
        instance: https://api.platform.dakota.xyz/customers/cst_2abc123
        request_id: req_7f3a8b2c
      properties:
        type:
          type: string
          format: uri
          description: |
            URI reference identifying the problem type.
            Resolves to human-readable documentation.
          example: https://docs.dakota.xyz/api-reference/errors#not-found
        title:
          type: string
          description: >-
            Short, human-readable summary of the problem type. Stable across
            occurrences.
          example: Customer Not Found
        status:
          type: integer
          description: HTTP status code for this occurrence.
          example: 404
        detail:
          type: string
          description: Human-readable explanation specific to this occurrence.
          example: Customer cst_2abc123 was not found in your organization.
        instance:
          type: string
          format: uri
          description: The request path that triggered this error.
          example: https://api.platform.dakota.xyz/customers/cst_2abc123
        request_id:
          type: string
          description: Unique request identifier. Include when contacting support.
          example: req_7f3a8b2c
        errors:
          type: array
          description: Field-level validation errors (present for validation failures).
          items:
            $ref: '#/components/schemas/ValidationError'
        resolution_url:
          type: string
          format: uri
          description: |
            A link the customer can follow to CLEAR this error, present only on
            problems with a concrete self-service remedy.

            Today this is returned by
            `#terms-not-accepted`, where it points at the hosted flow in which
            the outstanding agreement can be signed. The link is token-gated and
            usable as-is — send the customer to it directly rather than parsing
            it out of `detail`.
          example: >-
            https://onboarding.dakota.xyz/applications/2abc123?token=tok_7f3a8b2c
        user_message:
          type: string
          description: |
            A plain-language rendition of `detail` written for the end
            customer, present when one exists for this error. `detail` names
            request fields and actions so a machine caller (such as a payment
            agent drafting proposals) can self-correct; `user_message` says the
            same thing without API vocabulary. Clients that relay errors into a
            human surface (chat, email, UI) should show `user_message` when
            present and fall back to `detail`.
          example: >-
            ACH payments pay out USD, so a USDC payout isn't possible on this
            rail. Change the payout currency to USD and try again.
        reason:
          type: string
          description: >
            A stable, machine-readable code for why the request was refused,

            present only when Dakota has a typed reason for this error. Branch

            on `reason` rather than parsing `detail`.


            When `reason` is a value from the table below other than

            `signature_required` and `immutable_field`, `detail` is text Dakota

            writes for that reason, never a partner's or a bank's wording. For

            those two, `detail` is the text written for that specific refusal.

            In every case the wording can change, so do not parse it.


            This is an open set: new values are added over time and a value is

            never repurposed, so treat an unrecognized `reason` as absent.


            Which operations return it today:


            - `createAccount` (onramp, offramp and swap) and `createTransaction`
              (a one-off transaction creates an account): every value in the
              table except `immutable_field`; `signature_required` comes from
              `createTransaction` only.
            - `updateAccount`: `field_invalid` (a developer fee that is out of
              range), `resource_not_found`, and `immutable_field` (the change
              would alter the account's routing; create a new account instead).
            - `deleteAccount`: `resource_not_found`.

            - `createWalletTransaction` and `signWalletTypedData`:
              `check_unavailable` (503) when the address screen could not run.
            - `deletePolicy`: `policy_attached` (409, under governance
              enforcement) when a wallet still holds the policy.
            - Every operation authenticated with an API key:
              `api_key_expired` (401) and `ip_not_allowed` (403).
            - `createInstructions`: a payment-agent instruction that creates an
              account fails with the same `reason` values as `createAccount`,
              but `params.field` is never returned there: the response carries
              the other `params` keys only, because this operation has no
              public field names to map to.
            - Other operations may also set `reason`. Treat a `reason` you do
              not recognize as absent, as above, and never assume an operation
              that is not listed here omits it.

            | `reason` | Meaning | `params` |

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

            | `field_required` | A required request field is missing. | `field`
            |

            | `field_invalid` | A field is present but unusable. | `field`,
            `constraint`, `rail` |

            | `field_too_long` | A field is longer than the rail allows. |
            `field`, `max`, `actual`, `rail` |

            | `field_too_short` | A field is shorter than the rail allows. |
            `field`, `min`, `actual` |

            | `address_incomplete` | An address lacks parts the route needs. |
            `subject`, `fields` |

            | `unsupported_network` | The network is not supported. | `network`
            |

            | `unsupported_asset` | The asset does not exist on the network. |
            `asset`, `network` |

            | `no_route_available` | No payment route covers the request. |
            `direction`, `rail`, `currency`, `network` |

            | `onboarding_required` | The customer has not completed onboarding
            for a capability. | `capability` |

            | `entity_not_active` | Onboarding for a capability exists but is
            not yet usable. | `capability`, `status` |

            | `destination_unreachable` | The destination cannot be reached over
            the requested rail. | `rail`, `alternative`, `direction` |

            | `limit_exceeded` | An amount exceeds a ceiling. | `limit`, `max`,
            `configured`, `currency` |

            | `resource_not_found` | The named resource does not exist. |
            `resource` |

            | `duplicate_resource` | A matching resource already exists. |
            `resource` |

            | `request_rejected` | The request was refused and the reason is not
            disclosed. | none |

            | `signature_required` | The request must be signed. | none |

            | `immutable_field` | The field cannot be changed on an existing
            account; create a new one. | none |

            | `endorsement_required` | The signer-group change needs signatures
            from the group's governing members. Also returned, under governance
            enforcement, when an API key creates an x402 spend mandate. Also
            returned, under governance enforcement, when an `operate` API key
            sets an account's refund wallet (`return_address` or
            `return_crypto_address`) to an address that is not one of the
            customer's saved crypto destinations on the same network: save it as
            a crypto destination first. | none |

            | `insufficient_endorsements` | The signatures do not meet the
            signer group's governance quorum (403). When `params` are present,
            the group `signer_group_id` got `have` of the `need` distinct
            governing members it requires. When they are absent, no count is
            reported; usually no signature was counted at all, because one did
            not verify over the request's intent with the key of a member of a
            group allowed to endorse it, came from a payment-agent or
            card-settlement key, or repeated a signer. | `signer_group_id`,
            `have`, `need` (all or none) |

            | `webauthn_wrong_type` | A passkey signature was not an assertion:
            its `clientDataJSON.type` is not `webauthn.get` (for example, the
            output of a registration). Sign again with
            `navigator.credentials.get` (400 `validation_error`). | none |

            | `webauthn_user_not_present` | A passkey assertion lacks the
            user-present (UP) flag, so nobody confirmed it on the authenticator
            (400 `validation_error`). | none |

            | `webauthn_user_not_verified` | A passkey assertion lacks the
            user-verified (UV) flag. Refused only where Dakota enforces user
            verification (400 `validation_error`). | none |

            | `webauthn_rp_mismatch` | A passkey is bound to a relying party ID
            that is not allowed. Refused only where Dakota enforces the RP ID
            check (400 `validation_error`). | none |

            | `webauthn_origin_mismatch` | A passkey assertion was made on an
            origin that is not allowed. Refused only where Dakota enforces the
            origin check (400 `validation_error`). | none |

            | `stale_signer_group_version` | The signer group changed since the
            signatures were made; read its `version` and sign again. | none |

            | `below_threshold` | The removal would leave the signer group below
            a threshold it must keep. | none |

            | `invalid_governing_group` | The governing signer group is missing
            or no longer valid. | none |

            | `check_unavailable` | A required safety check could not run, so
            nothing was sent; retry later with the same idempotency key. | none
            |

            | `api_key_expired` | The API key is past its `expires_at` (401).
            Use a current key. | none |

            | `ip_not_allowed` | The request came from an address outside the
            API key's `allowed_cidrs` (403). | none |

            | `session_required` | Only a person's own signed-in session may do
            this; an API key cannot. Nothing was changed. | none |

            | `unmeetable_signer_groups` | Governance enforcement cannot be
            turned on while the listed signer groups could never be governed
            under it. Nothing was changed. | none |

            | `policy_attached` | Under governance enforcement, a policy still
            attached to a wallet cannot be deleted (409). Nothing was changed.
            Detach it from each wallet first. `wallet_ids` lists up to 20 of the
            wallets, comma-separated; `wallet_count` is the total. |
            `wallet_ids`, `wallet_count` |
          example: field_too_long
        code:
          type: string
          description: |
            A stable snake_case error code for the signer-group governance
            refusals, equal to `reason` for them: `endorsement_required`,
            `insufficient_endorsements`, `stale_signer_group_version`,
            `below_threshold`, `invalid_governing_group` and `policy_attached`,
            and the passkey refusals of a signed request (`webauthn_wrong_type`,
            `webauthn_user_not_present`, `webauthn_user_not_verified`,
            `webauthn_rp_mismatch` and `webauthn_origin_mismatch`, on a 400
            `validation_error`). Absent for every other problem.
          example: insufficient_endorsements
        params:
          type: object
          description: |
            Parameters of `reason`. Every value is a string: a number, a
            token from a closed set, or the public name of a request field
            (`field` is expressed in this operation's request body, and is
            omitted when the offending value has no public name). Never free
            text. Present only alongside `reason`, and only when the reason
            has parameters.
          additionalProperties:
            type: string
          example:
            field: payment_reference
            max: '35'
            actual: '40'
            rail: swift
    Signer:
      type: object
      description: >-
        A signer is a public key that can sign intents and it is part of a
        signer group
      required:
        - id
        - name
        - public_key
        - key_type
      properties:
        id:
          $ref: '#/components/schemas/KSUID'
        client_id:
          $ref: '#/components/schemas/KSUID'
        name:
          type: string
          description: The signer name
          example: Marc
        public_key:
          type: string
          description: |
            The signer public key. For KEY_TYPE_ES256 this must be a
            base64-encoded X.509 SubjectPublicKeyInfo (PKIX) for an ECDSA
            P-256 key. Both PEM-wrapped (with BEGIN/END PUBLIC KEY headers)
            and raw DER encodings are accepted.

            For KEY_TYPE_WEBAUTHN this must be a base64-encoded COSE public
            key. Only ES256 (EC2 / P-256, COSE alg -7) and RS256 (RSA,
            2048-bit minimum, COSE alg -257) keys are supported; other
            algorithms and curves are rejected. See the WebAuthn & Passkey
            Signing guide for how each signatures[] entry is then built.
        key_type:
          type: string
          description: Type of the key
          enum:
            - ES256
            - WEBAUTHN
        removed_at:
          type: integer
          format: int64
          description: >
            Epoch seconds at which this signer was removed from the containing

            signer group. Present only for entries in a group's
            `removed_members`

            (i.e. when `include_removed=true`); absent for active members.
    ValidationError:
      type: object
      required:
        - field
        - message
      properties:
        field:
          type: string
          description: Field path using dot notation for nested fields.
          example: bank_account.routing_number
        message:
          type: string
          description: Human-readable description of the field error.
          example: Routing number must be exactly 9 digits
        code:
          type: string
          description: Machine-readable error code for this field.
          example: invalid_format
  parameters:
    IdempotencyKeyHeader:
      name: x-idempotency-key
      in: header
      required: true
      description: >-
        Unique key (UUID) to ensure request idempotency on POST, PUT and PATCH
        requests.


        A key is scoped to your client, the HTTP method and the path, and is
        remembered for 24 hours after a

        successful (below 400) response. Repeating the same request (same JSON
        body, whatever the key order or

        whitespace) with the same key within that window returns the original
        response with

        `X-Idempotent-Replayed: true` instead of executing the request again.
        Using the same key on the same

        endpoint with a different body returns `422` with problem type
        `idempotency-key-reused`; the request is

        not executed. Error responses (4xx and 5xx) are not remembered, so a
        request refused for a fixable reason

        can be corrected and retried under the same key. Request bodies that are
        not JSON (for example file

        uploads) are not compared.
      schema:
        type: string
        format: uuid
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

````

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