> ## 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.

# List a customer's recipients

> Get a list of all recipients for the given customer ID



## OpenAPI

````yaml /openapi.yaml get /customers/{customer_id}/recipients
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-alpha: true
    description: >-
      Alpha — 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-alpha: true
    description: >-
      Alpha — 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-alpha: true
    description: >-
      Alpha — read-only account insight: a deterministic report over a
      customer's agentic activity (funding balances, upcoming obligations,
      failures, mandate headroom and expiry) plus an advisory chat that narrates
      it. 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: 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: 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:
  /customers/{customer_id}/recipients:
    parameters:
      - name: customer_id
        in: path
        required: true
        schema:
          $ref: '#/components/schemas/KSUID'
    get:
      tags:
        - Recipients
      summary: List a customer's recipients
      description: Get a list of all recipients for the given customer ID
      operationId: listRecipients
      parameters:
        - $ref: '#/components/parameters/LimitParam'
        - $ref: '#/components/parameters/StartingAfterParam'
        - $ref: '#/components/parameters/EndingBeforeParam'
      responses:
        '200':
          description: List of recipients
          content:
            application/json:
              schema:
                allOf:
                  - $ref: '#/components/schemas/PaginatedListResponse'
                  - type: object
                    properties:
                      data:
                        type: array
                        items:
                          $ref: '#/components/schemas/RecipientResponse'
              example:
                data:
                  - id: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
                    name: Acme Corporation
                    address:
                      street1: 123 Main St
                      street2: Apt 4B
                      street3: Building C
                      city: San Francisco
                      region: California
                      postal_code: '94105'
                      country: US
                    status: active
                    destinations:
                      - destination_id: 1NFHrqBHb3cTfLVkFSGmHZqdDPi
                        destination_type: crypto
                        name: My Ethereum Wallet
                        crypto_address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
                        family: evm
                        network_id: ethereum-mainnet
                meta:
                  total_count: 100
                  has_more_after: true
                  has_more_before: false
        '400':
          description: Invalid request
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
              example:
                type: https://docs.dakota.xyz/api-reference/errors#invalid-request
                title: Invalid request
                status: 400
                detail: Invalid request
                instance: >-
                  https://api.platform.dakota.xyz/customers/example-id/recipients
                request_id: req_01hzy6y7v8w9x0y1z2a3b4c5d6
        '401':
          description: Unauthorized
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
              example:
                type: >-
                  https://docs.dakota.xyz/api-reference/errors#authentication-error
                title: Unauthorized
                status: 401
                detail: Unauthorized
                instance: >-
                  https://api.platform.dakota.xyz/customers/example-id/recipients
                request_id: req_01hzy6y7v8w9x0y1z2a3b4c5d6
        '403':
          description: Forbidden
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
              example:
                type: https://docs.dakota.xyz/api-reference/errors#forbidden
                title: Forbidden
                status: 403
                detail: Forbidden
                instance: >-
                  https://api.platform.dakota.xyz/customers/example-id/recipients
                request_id: req_01hzy6y7v8w9x0y1z2a3b4c5d6
        '404':
          description: Not found
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
              example:
                type: https://docs.dakota.xyz/api-reference/errors#not-found
                title: Not found
                status: 404
                detail: Not found
                instance: >-
                  https://api.platform.dakota.xyz/customers/example-id/recipients
                request_id: req_01hzy6y7v8w9x0y1z2a3b4c5d6
      externalDocs:
        description: Read full guide in docs
        url: >-
          https://docs.dakota.xyz/api-reference/recipients/list-a-customers-recipients
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
    PaginatedListResponse:
      type: object
      description: Wrapper for paginated list responses
      required:
        - data
        - meta
      properties:
        data:
          type: array
          description: List of objects returned by the API
          items:
            type: object
        meta:
          $ref: '#/components/schemas/Meta'
    RecipientResponse:
      type: object
      title: Recipient Response
      description: Response containing recipient details.
      required:
        - id
        - name
        - status
      properties:
        id:
          $ref: '#/components/schemas/KSUID'
        name:
          type: string
          description: Name of the recipient entity.
          example: Acme Corporation
        address:
          $ref: '#/components/schemas/Address'
          nullable: true
          type: object
        status:
          type: string
          description: Current status of the recipient
          enum:
            - unused
            - active
            - frozen
          example: active
        destinations:
          type: array
          description: List of destinations associated with this recipient.
          items:
            $ref: '#/components/schemas/DestinationResponseUnion'
    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.
    Meta:
      type: object
      description: Meta information about the response
      required:
        - total_count
        - has_more_after
        - has_more_before
      properties:
        total_count:
          type: integer
          description: Total number of items available
          example: 100
        has_more_after:
          type: boolean
          description: Indicates whether there are more items that follow this set.
          example: true
        has_more_before:
          type: boolean
          description: Indicates whether there are more items that precede this set.
          example: false
    Address:
      type: object
      title: Address
      description: >-
        Standardized physical address format used throughout the Dakota platform
        for user and entity addresses.
      required:
        - street1
        - city
        - country
      properties:
        street1:
          type: string
          description: Primary street address line
          example: 123 Main St
        street2:
          type: string
          description: >-
            Secondary address information such as apartment, suite, or unit
            number
          example: Apt 4B
        street3:
          type: string
          description: Additional address information like building name or floor
          example: Building C
        city:
          type: string
          description: City or locality name
          example: San Francisco
        region:
          type: string
          description: Full name of state, province, or region
          example: California
        postal_code:
          type: string
          description: Postal or ZIP code
          example: '94105'
        country:
          type: string
          description: ISO 3166-1 alpha-2 country code (two-letter country code)
          example: US
          minLength: 2
          maxLength: 2
    DestinationResponseUnion:
      title: Destination Response Union
      description: >-
        Union type for different destination responses with destination_type
        discriminator
      oneOf:
        - $ref: '#/components/schemas/CryptoDestinationResponse'
        - $ref: '#/components/schemas/FiatUSDestinationResponse'
        - $ref: '#/components/schemas/FiatIBANDestinationResponse'
      discriminator:
        propertyName: destination_type
        mapping:
          crypto:
            $ref: '#/components/schemas/CryptoDestinationResponse'
          fiat_us:
            $ref: '#/components/schemas/FiatUSDestinationResponse'
          fiat_iban:
            $ref: '#/components/schemas/FiatIBANDestinationResponse'
    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
    CryptoDestinationResponse:
      type: object
      title: Crypto Destination Response
      description: Response for a crypto destination.
      allOf:
        - $ref: '#/components/schemas/DestinationResponse'
        - type: object
          required:
            - name
            - crypto_address
            - family
          properties:
            destination_type:
              type: string
              enum:
                - crypto
              default: crypto
            name:
              type: string
              description: Name of the destination for reference
              example: My Ethereum Wallet
            crypto_address:
              type: string
              description: Wallet address for the crypto account.
              example: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
            family:
              $ref: '#/components/schemas/Family'
            network_id:
              $ref: '#/components/schemas/NetworkId'
    FiatUSDestinationResponse:
      type: object
      title: US Fiat Destination Response
      description: Response for a US fiat destination.
      allOf:
        - $ref: '#/components/schemas/DestinationResponse'
        - type: object
          required:
            - account_holder_name
            - bank_name
            - bank_address
            - capabilities
            - aba_routing_number
            - account_number
            - account_type
          properties:
            destination_type:
              type: string
              enum:
                - fiat_us
              default: fiat_us
            name:
              type: string
              description: Name of the destination for reference
              example: Primary US Bank Account
            aba_routing_number:
              type: string
              description: ABA routing number for ACH transfers.
              example: '123456789'
            aba_wire_routing_number:
              type: string
              description: ABA routing number for wire transfers (optional).
              nullable: true
              example: '123456789'
            account_number:
              type: string
              description: Account number for the US bank account.
              example: '123456789'
            account_type:
              type: string
              description: Type of bank account.
              enum:
                - checking
                - savings
              example: checking
            account_holder_name:
              type: string
              description: Name of the account holder.
              example: John Doe
            account_holder_address:
              $ref: '#/components/schemas/Address'
            account_holder_phone:
              type: string
              description: Phone number of the account holder.
              example: '1234567890'
            bank_name:
              type: string
              description: Name of the bank.
              example: Bank of America
            bank_address:
              $ref: '#/components/schemas/Address'
            bank_phone:
              type: string
              description: Phone number of the bank.
              example: '1234567890'
            capabilities:
              $ref: '#/components/schemas/Capabilities'
    FiatIBANDestinationResponse:
      type: object
      title: IBAN Fiat Destination Response
      description: >-
        Response for an IBAN bank account destination (for SWIFT and SWIFT
        transfers).
      allOf:
        - $ref: '#/components/schemas/DestinationResponse'
        - type: object
          required:
            - iban
            - account_holder_name
            - capabilities
          properties:
            destination_type:
              type: string
              enum:
                - fiat_iban
              default: fiat_iban
            name:
              type: string
              description: Name of the destination for reference
              example: International Business Account
            iban:
              type: string
              description: IBAN (International Bank Account Number) for the account.
              example: DE89370400440532013000
            bic:
              type: string
              description: >-
                BIC/SWIFT code for the international bank account (optional for
                required for SWIFT).
              example: DEUTDEFFXXX
            account_holder_name:
              type: string
              description: Name of the account holder.
              example: John Doe
            account_holder_address:
              $ref: '#/components/schemas/Address'
            account_holder_phone:
              type: string
              description: Phone number of the account holder.
              example: '1234567890'
            bank_name:
              type: string
              description: Name of the bank.
              example: Deutsche Bank
            bank_address:
              $ref: '#/components/schemas/Address'
            capabilities:
              $ref: '#/components/schemas/Capabilities'
    DestinationResponse:
      type: object
      title: Destination Response
      description: >-
        Base schema for destination responses with a discriminator based on
        destination type.
      required:
        - destination_id
        - destination_type
      properties:
        destination_id:
          $ref: '#/components/schemas/KSUID'
        destination_type:
          type: string
          description: The type of destination.
          enum:
            - crypto
            - fiat_us
            - fiat_iban
      discriminator:
        propertyName: destination_type
        mapping:
          crypto:
            $ref: '#/components/schemas/CryptoDestinationResponse'
          fiat_us:
            $ref: '#/components/schemas/FiatUSDestinationResponse'
          fiat_iban:
            $ref: '#/components/schemas/FiatIBANDestinationResponse'
    Family:
      type: string
      title: Family
      description: Blockchain family for the crypto account.
      enum:
        - evm
        - solana
      example: evm
    NetworkId:
      type: string
      description: Identifier for a blockchain network
      example: ethereum-mainnet
      enum:
        - ethereum-mainnet
        - ethereum-sepolia
        - ethereum-goerli
        - ethereum-holesky
        - solana-mainnet
        - solana-devnet
        - solana-testnet
        - base-mainnet
        - base-sepolia
        - arbitrum-mainnet
        - arbitrum-sepolia
        - optimism-mainnet
        - optimism-sepolia
        - polygon-mainnet
        - polygon-amoy
      minLength: 1
      maxLength: 30
    Capabilities:
      type: array
      title: Capabilities
      description: |-
        List of payment capabilities supported by a rail. Multiple values may
        be supplied; the list is not limited to one entry. Which values are
        valid depends on the resource: on-ramp accounts accept any rail and
        expand `us_bank_account` to `ach` and `fedwire`; IBAN destinations
        accept `swift` and `sepa` only.
      items:
        $ref: '#/components/schemas/PaymentCapability'
      minItems: 1
      example:
        - ach
        - fedwire
    PaymentCapability:
      type: string
      title: Payment Capability
      description: >-
        Type of payment rail capability supported. For onramp accounts,
        `us_bank_account` indicates the account accepts ACH, Wire (Fedwire), and
        FedNow deposits interchangeably. `fednow` is the FedNow instant
        US-domestic USD rail for payouts and deposits — $500k per-transaction
        cap on payouts; a payout destination whose bank cannot receive FedNow is
        rejected at account creation with problem type
        `https://docs.dakota.xyz/api-reference/errors#fednow-destination-unreachable`
        — route that destination over `ach` instead.
      enum:
        - ach
        - fedwire
        - swift
        - us_bank_account
        - fednow
      example: ach
  parameters:
    LimitParam:
      name: limit
      in: query
      required: false
      description: >-
        A limit on the number of objects to be returned. Limit can range between
        1 and 100, and the default is 20.
      schema:
        type: integer
        minimum: 1
        maximum: 100
        default: 20
    StartingAfterParam:
      name: starting_after
      in: query
      required: false
      description: >-
        A cursor for use in pagination. `starting_after` is a KSUID for the
        object you are listing that defines your place in the list. For
        instance, if you make a list request and receive 100 objects, ending
        with ID `2B5J8KZ9N7M1K3P6Q8R4T7V9`, your subsequent call can include
        `starting_after=2B5J8KZ9N7M1K3P6Q8R4T7V9` in order to fetch the next
        page of the list.
      schema:
        $ref: '#/components/schemas/KSUID'
    EndingBeforeParam:
      name: ending_before
      in: query
      required: false
      description: >-
        A cursor for use in pagination. `ending_before` is a KSUID for the
        object you are listing that defines your place in the list. For
        instance, if you make a list request and receive 100 objects, starting
        with ID `2B5J8KZ9N7M1K3P6Q8R4T7V9`, your subsequent call can include
        `ending_before=2B5J8KZ9N7M1K3P6Q8R4T7V9` in order to fetch the previous
        page of the list.
      schema:
        $ref: '#/components/schemas/KSUID'
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

````