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

# Get your developer fee statement

> Returns what your developer fees came to over a date range: the totals
earned and paid in the range, the balance owed as of the range end,
per-month sub-totals, per-asset earnings, and the fee transactions the
earned figure is made of.

The statement is always your own. Nothing in a request names a client.

`owed` is cumulative and is not bounded by `from`: a balance you were
owed before the range still counts. Payouts are initiated by Dakota, so
an owed balance is what is due rather than what is scheduled.

All money figures are decimal strings. The USD totals are USD; a
per-asset `earned` is in that asset's own units.




## OpenAPI

````yaml /openapi.yaml get /developer-fees/statement
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: 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:
  /developer-fees/statement:
    get:
      tags:
        - Payouts
      summary: Get your developer fee statement
      description: |
        Returns what your developer fees came to over a date range: the totals
        earned and paid in the range, the balance owed as of the range end,
        per-month sub-totals, per-asset earnings, and the fee transactions the
        earned figure is made of.

        The statement is always your own. Nothing in a request names a client.

        `owed` is cumulative and is not bounded by `from`: a balance you were
        owed before the range still counts. Payouts are initiated by Dakota, so
        an owed balance is what is due rather than what is scheduled.

        All money figures are decimal strings. The USD totals are USD; a
        per-asset `earned` is in that asset's own units.
      operationId: getMyDeveloperFeeStatement
      parameters:
        - name: from
          in: query
          required: false
          schema:
            type: integer
            format: int64
          description: Unix seconds lower bound on the fee's completion time (inclusive).
        - name: to
          in: query
          required: false
          schema:
            type: integer
            format: int64
          description: |
            Unix seconds upper bound on the fee's completion time (inclusive).
            Also the as-of date for the owed balance.
        - name: page
          in: query
          required: false
          schema:
            type: integer
            minimum: 1
            default: 1
          description: |
            1-based page of the fee transactions list. The page size is 250;
            `transactions.total` reports the full count so you can tell when a
            range runs past one page.
      responses:
        '200':
          description: Your developer fee statement over the range.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DeveloperFeeStatementResponse'
              example:
                totals:
                  earned: '12480.55'
                  paid: '9200.00'
                  owed: '3280.55'
                months:
                  - month: 2026-09
                    earned: '2140.20'
                    paid: '0'
                  - month: 2026-08
                    earned: '3510.80'
                    paid: '3510.80'
                assets:
                  - asset: >-
                      eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913
                    symbol: USDC
                    earned: '10204.30'
                  - asset: >-
                      eip155:8453/erc20:0x3788806ff15b639146a0309218190572ff365059
                    symbol: RD
                    earned: '1890.25'
                transactions:
                  items:
                    - id: 3JSAEmeRoI3MYTxJR43kVc1kQ82
                      date: 1789603200
                      asset: >-
                        eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913
                      symbol: USDC
                      volume: '40000.00'
                      fee: '40.00'
                  total: 1284
        '401':
          description: Unauthorized.
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
        '502':
          description: The figures could not be retrieved.
          content:
            application/problem+json:
              schema:
                $ref: '#/components/schemas/ProblemDetails'
components:
  schemas:
    DeveloperFeeStatementResponse:
      type: object
      required:
        - totals
        - months
        - assets
        - transactions
      properties:
        totals:
          $ref: '#/components/schemas/DeveloperFeeStatementTotals'
        months:
          type: array
          items:
            $ref: '#/components/schemas/DeveloperFeeStatementMonth'
        assets:
          type: array
          items:
            $ref: '#/components/schemas/DeveloperFeeStatementAsset'
        transactions:
          $ref: '#/components/schemas/DeveloperFeeStatementTransactions'
    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.
    DeveloperFeeStatementTotals:
      type: object
      required:
        - earned
        - paid
        - owed
      properties:
        earned:
          type: string
          description: USD decimal string, earned in range.
        paid:
          type: string
          description: USD decimal string, paid in range.
        owed:
          type: string
          description: USD decimal string, owed as-of the range end (cumulative).
    DeveloperFeeStatementMonth:
      type: object
      required:
        - month
        - earned
        - paid
      properties:
        month:
          type: string
          description: YYYY-MM (UTC)
        earned:
          type: string
          description: USD decimal string
        paid:
          type: string
          description: USD decimal string
    DeveloperFeeStatementAsset:
      type: object
      required:
        - asset
        - symbol
        - earned
      properties:
        asset:
          type: string
          description: CAIP-19 asset id (chain-scoped) or bare fiat symbol.
        symbol:
          type: string
          description: Resolved display symbol (may be empty).
        earned:
          type: string
          description: Decimal string, asset units — Σ fees earned in range for this asset.
    DeveloperFeeStatementTransactions:
      type: object
      required:
        - items
        - total
      properties:
        items:
          type: array
          items:
            $ref: '#/components/schemas/DeveloperFeeStatementTransaction'
        total:
          type: integer
          format: int64
    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
    DeveloperFeeStatementTransaction:
      type: object
      required:
        - id
        - date
        - asset
        - symbol
        - volume
        - fee
      properties:
        id:
          type: string
        date:
          type: integer
          format: int64
          description: Unix seconds (completed_at)
        asset:
          type: string
          description: CAIP-19 asset id or bare fiat symbol of the inbound leg.
        symbol:
          type: string
          description: Resolved display symbol.
        volume:
          type: string
          description: decimal string, inbound leg-0 amount
        fee:
          type: string
          description: decimal string, client_fee_amount
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key

````