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

# List Payout Breakup Details

> Returns paginated individual balance ledger entries for a payout, with each entry's amount pro-rated into the payout's currency.



## OpenAPI

````yaml get /payouts/{payout_id}/breakup/details
openapi: 3.1.0
info:
  title: public
  description: ''
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0
  version: 1.118.3
servers:
  - url: https://test.dodopayments.com/
    description: Test Mode Server Host
  - url: https://live.dodopayments.com/
    description: Live Mode Server Host
security: []
tags:
  - name: Products
  - name: Payments
  - name: Subscriptions
  - name: Addons
  - name: Customers
  - name: Refunds
  - name: Disputes
  - name: Events
  - name: License Keys
  - name: Entitlements
  - name: Licenses
  - name: Discounts
  - name: Meters
  - name: Credit Entitlements
  - name: Credit Entitlement Balances
  - name: Outgoing Webhooks
  - name: Checkout
  - name: Webhook Events
  - name: Payment Connector Webhooks
  - name: Moderation
paths:
  /payouts/{payout_id}/breakup/details:
    get:
      tags:
        - Payouts
      description: >-
        Returns paginated individual balance ledger entries for a payout. Each
        entry is converted into the payout's currency at the rate the payout
        settled at. Supports pagination via `page_size` (default 10, max 100)
        and `page_number` (default 0) query parameters.
      operationId: get_payout_breakup_v3_details_public
      parameters:
        - name: payout_id
          in: path
          description: Id of the Payout to get breakup for
          required: true
          schema:
            type: string
          example: pyt_zFTrrn4sk3x3y2vjDBW3T
        - name: page_size
          in: query
          description: 'Number of items per page. Default: 10, Max: 100.'
          required: false
          schema:
            type: integer
            format: int32
            minimum: 0
          style: form
        - name: page_number
          in: query
          description: 'Page number (0-indexed). Default: 0.'
          required: false
          schema:
            type: integer
            format: int32
            minimum: 0
          style: form
      responses:
        '200':
          description: Per-row payout breakup in payout currency
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PayoutBreakupDetailResponse'
        '404':
          description: Payout not found
        '500':
          description: Something went wrong
      security:
        - API_KEY: []
      x-codeSamples:
        - lang: JavaScript
          source: >-
            import DodoPayments from 'dodopayments';


            const client = new DodoPayments({
              bearerToken: process.env['DODO_PAYMENTS_API_KEY'], // This is the default and can be omitted
            });


            // Automatically fetches more pages as needed.

            for await (const detailListResponse of
            client.payouts.breakup.details.list(
              'pyt_zFTrrn4sk3x3y2vjDBW3T',
            )) {
              console.log(detailListResponse.id);
            }
        - lang: Python
          source: |-
            import os
            from dodopayments import DodoPayments

            client = DodoPayments(
                bearer_token=os.environ.get("DODO_PAYMENTS_API_KEY"),  # This is the default and can be omitted
            )
            page = client.payouts.breakup.details.list(
                payout_id="pyt_zFTrrn4sk3x3y2vjDBW3T",
            )
            page = page.items[0]
            print(page.id)
        - lang: Go
          source: "package main\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\n\t\"github.com/dodopayments/dodopayments-go\"\n\t\"github.com/dodopayments/dodopayments-go/option\"\n)\n\nfunc main() {\n\tclient := dodopayments.NewClient(\n\t\toption.WithBearerToken(\"My Bearer Token\"),\n\t)\n\tpage, err := client.Payouts.Breakup.Details.List(\n\t\tcontext.TODO(),\n\t\t\"pyt_zFTrrn4sk3x3y2vjDBW3T\",\n\t\tdodopayments.PayoutBreakupDetailListParams{},\n\t)\n\tif err != nil {\n\t\tpanic(err.Error())\n\t}\n\tfmt.Printf(\"%+v\\n\", page)\n}\n"
        - lang: Java
          source: >-
            package com.dodopayments.api.example;


            import com.dodopayments.api.client.DodoPaymentsClient;

            import com.dodopayments.api.client.okhttp.DodoPaymentsOkHttpClient;

            import
            com.dodopayments.api.models.payouts.breakup.details.DetailListPage;

            import
            com.dodopayments.api.models.payouts.breakup.details.DetailListParams;


            public final class Main {
                private Main() {}

                public static void main(String[] args) {
                    DodoPaymentsClient client = DodoPaymentsOkHttpClient.fromEnv();

                    DetailListPage page = client.payouts().breakup().details().list("pyt_zFTrrn4sk3x3y2vjDBW3T");
                }
            }
        - lang: Kotlin
          source: >-
            package com.dodopayments.api.example


            import com.dodopayments.api.client.DodoPaymentsClient

            import com.dodopayments.api.client.okhttp.DodoPaymentsOkHttpClient

            import
            com.dodopayments.api.models.payouts.breakup.details.DetailListPage

            import
            com.dodopayments.api.models.payouts.breakup.details.DetailListParams


            fun main() {
                val client: DodoPaymentsClient = DodoPaymentsOkHttpClient.fromEnv()

                val page: DetailListPage = client.payouts().breakup().details().list("pyt_zFTrrn4sk3x3y2vjDBW3T")
            }
        - lang: Ruby
          source: >-
            require "dodopayments"


            dodo_payments = Dodopayments::Client.new(
              bearer_token: "My Bearer Token",
              environment: "test_mode" # defaults to "live_mode"
            )


            page =
            dodo_payments.payouts.breakup.details.list("pyt_zFTrrn4sk3x3y2vjDBW3T")


            puts(page)
        - lang: PHP
          source: |-
            <?php

            require_once dirname(__DIR__) . '/vendor/autoload.php';

            use Dodopayments\Client;
            use Dodopayments\Core\Exceptions\APIException;

            $client = new Client(
              bearerToken: getenv('DODO_PAYMENTS_API_KEY') ?: 'My Bearer Token',
              environment: 'test_mode',
            );

            try {
              $page = $client->payouts->breakup->details->list(
                'pyt_zFTrrn4sk3x3y2vjDBW3T', pageNumber: 0, pageSize: 0
              );

              var_dump($page);
            } catch (APIException $e) {
              echo $e->getMessage();
            }
        - lang: C#
          source: >-
            using System;

            using DodoPayments.Client;

            using DodoPayments.Client.Models.Payouts.Breakup.Details;


            DodoPaymentsClient client = new();


            DetailListParams parameters = new() { PayoutID =
            "pyt_zFTrrn4sk3x3y2vjDBW3T" };


            var page = await client.Payouts.Breakup.Details.List(parameters);

            await foreach (var item in page.Paginate())

            {
                Console.WriteLine(item);
            }
        - lang: Rust
          source: |-
            use dodopayments::Client;

            #[tokio::main]
            async fn main() -> dodopayments::Result<()> {
                let client = Client::from_env()?;
                let payout_id = "payout_id";
                let result = client
                    .payouts()
                    .breakup()
                    .details()
                    .list()
                    .payout_id(payout_id)
                    .query(serde_json::json!({}))
                    .await?;
                println!("{result:?}");
                Ok(())
            }
components:
  schemas:
    PayoutBreakupDetailResponse:
      type: object
      description: Paginated response containing individual payout breakup entries.
      required:
        - items
        - unattributed
      properties:
        items:
          type: array
          items:
            $ref: '#/components/schemas/PayoutBreakupDetailRow'
          description: List of payout breakup detail entries.
        unattributed:
          type: integer
          format: int64
          description: >-
            The payout amount less every entry, in the payout's currency and its
            smallest unit.


            The entries alone do not sum to the payout. This field holds the
            difference, so the

            entries and this field together reconcile against the payout. It
            takes either sign; see

            `PayoutBreakupV3Row` for what each sign means. The value covers the
            whole payout, not

            the page.
    PayoutBreakupDetailRow:
      type: object
      description: >-
        Individual balance ledger entry for a payout, converted into the
        payout's currency.
      required:
        - id
        - event_type
        - original_amount
        - original_currency
        - created_at
        - usd_equivalent_amount
        - payout_currency_amount
      properties:
        created_at:
          type: string
          format: date-time
          description: Timestamp when this entry was created.
        description:
          type:
            - string
            - 'null'
          description: Human-readable description of the transaction.
        event_type:
          type: string
          description: >-
            The type of balance ledger event (e.g., "payment", "refund",
            "dispute", "payment_fees").
        id:
          type: string
          description: Unique identifier of the balance ledger entry.
        original_amount:
          type: integer
          format: int64
          description: >-
            Original amount in the original currency, in that currency's
            smallest unit

            (cents for USD, yen for JPY, fils for KWD).
        original_currency:
          type: string
          description: Original currency as ISO 4217 code (e.g., "USD", "EUR").
        payout_currency_amount:
          type: integer
          format: int64
          description: >-
            Amount in the payout's currency, in that currency's smallest unit

            (cents for USD, yen for JPY, fils for KWD). The entry is converted
            at the rate the payout

            settled at. These amounts sum to the value of the entries, which can
            be less than the

            payout: the grouped breakup reports the difference as
            `unattributed`.
        reference_object_id:
          type:
            - string
            - 'null'
          description: >-
            ID of the related object (e.g., payment ID, refund ID) if
            applicable.
        usd_equivalent_amount:
          type: integer
          format: int64
          description: USD equivalent of the original amount (in cents).
  securitySchemes:
    API_KEY:
      type: http
      scheme: bearer

````

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