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

# Get US Derivatives Balance Summary

> Get a summary of balances for CFM trading



## OpenAPI

````yaml GET /api/v3/brokerage/cfm/balance_summary
openapi: 3.0.0
info:
  title: Coinbase Advanced Trade API
  version: '0.1'
servers:
  - url: https://api.coinbase.com
security:
  - apiKeyAuth: []
paths:
  /api/v3/brokerage/cfm/balance_summary:
    get:
      tags:
        - Futures
      summary: Get Futures Balance Summary
      description: Get a summary of balances for CFM trading
      operationId: RetailBrokerageApi_GetFCMBalanceSummary
      responses:
        '200':
          description: A successful response.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/coinbase.retail.rest.proxy.fcm.GetFCMBalanceSummaryResponse
            text/event-stream:
              schema:
                $ref: >-
                  #/components/schemas/coinbase.retail.rest.proxy.fcm.GetFCMBalanceSummaryResponse
        default:
          description: An unexpected error response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/grpc.gateway.runtime.Error'
            text/event-stream:
              schema:
                $ref: '#/components/schemas/grpc.gateway.runtime.Error'
components:
  schemas:
    coinbase.retail.rest.proxy.fcm.GetFCMBalanceSummaryResponse:
      type: object
      properties:
        balance_summary:
          allOf:
            - $ref: >-
                #/components/schemas/coinbase.retail.rest.proxy.fcm.FCMBalanceSummary
    grpc.gateway.runtime.Error:
      type: object
      properties:
        error:
          type: string
        code:
          type: integer
          format: int32
        message:
          type: string
        details:
          type: array
          items:
            $ref: '#/components/schemas/google.protobuf.Any'
    coinbase.retail.rest.proxy.fcm.FCMBalanceSummary:
      type: object
      properties:
        futures_buying_power:
          description: >-
            The amount of your cash balance that is available to trade CFM
            futures
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        total_usd_balance:
          description: >-
            Aggregate USD maintained across your CFTC-regulated futures account
            and your Coinbase Inc. spot account
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        cbi_usd_balance:
          description: USD maintained in your Coinbase Inc. spot account
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        cfm_usd_balance:
          description: >-
            USD maintained in your CFTC-regulated futures account. Funds held in
            your futures account are not available to trade spot
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        total_open_orders_hold_amount:
          description: Your total balance on hold for spot and futures open orders
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        unrealized_pnl:
          description: Your current unrealized PnL across all open positions
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        daily_realized_pnl:
          description: >-
            Your realized PnL from the current trade date. May include profit or
            loss from positions you've closed on the current trade date
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        initial_margin:
          description: >-
            Margin required to initiate futures positions. Once futures orders
            are placed, these funds cannot be used to trade spot. The actual
            amount of funds necessary to support executed futures orders will be
            moved to your futures account
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        available_margin:
          description: >-
            Funds available to meet your anticipated margin requirement. This
            includes your CBI spot USD, CFM futures USD, and Futures PnL, less
            any holds for open spot or futures orders
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        liquidation_threshold:
          description: >-
            When your available funds for collateral drop to the liquidation
            threshold, some or all of your futures positions will be liquidated
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        liquidation_buffer_amount:
          description: >-
            Funds available in excess of the liquidation threshold, calculated
            as available margin minus liquidation threshold. If your liquidation
            buffer amount reaches 0, your futures positions and/or open orders
            will be liquidated as necessary
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        liquidation_buffer_percentage:
          type: string
          description: >-
            Funds available in excess of the liquidation threshold expressed as
            a percentage. If your liquidation buffer percentage reaches 0%, your
            futures positions and/or open orders will be liquidated as necessary
        intraday_margin_window_measure:
          allOf:
            - $ref: >-
                #/components/schemas/coinbase.retail.rest.proxy.fcm.FcmMarginWindowMeasure
        overnight_margin_window_measure:
          allOf:
            - $ref: >-
                #/components/schemas/coinbase.retail.rest.proxy.fcm.FcmMarginWindowMeasure
        total_pending_transfers_amount:
          description: Total value of pending transfers
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
        funding_pnl:
          description: Portfolio funding PnL (only for US Perpetuals Futures)
          allOf:
            - $ref: '#/components/schemas/coinbase.consumer.shared.common.Amount'
    google.protobuf.Any:
      type: object
      properties:
        type_url:
          type: string
          description: >-
            A URL/resource name that uniquely identifies the type of the
            serialized

            protocol buffer message. This string must contain at least

            one "/" character. The last segment of the URL's path must represent

            the fully qualified name of the type (as in

            `path/google.protobuf.Duration`). The name should be in a canonical
            form

            (e.g., leading "." is not accepted).


            In practice, teams usually precompile into the binary all types that
            they

            expect it to use in the context of Any. However, for URLs which use
            the

            scheme `http`, `https`, or no scheme, one can optionally set up a
            type

            server that maps type URLs to message definitions as follows:


            * If no scheme is provided, `https` is assumed.

            * An HTTP GET on the URL must yield a [google.protobuf.Type][]
              value in binary format, or produce an error.
            * Applications are allowed to cache lookup results based on the
              URL, or have them precompiled into a binary to avoid any
              lookup. Therefore, binary compatibility needs to be preserved
              on changes to types. (Use versioned type names to manage
              breaking changes.)

            Note: this functionality is not currently available in the official

            protobuf release, and it is not used for type URLs beginning with

            type.googleapis.com. As of May 2023, there are no widely used type
            server

            implementations and no plans to implement one.


            Schemes other than `http`, `https` (or the empty scheme) might be

            used with implementation specific semantics.
        value:
          type: string
          format: byte
          description: >-
            Must be a valid serialized protocol buffer of the above specified
            type.
      description: >-
        `Any` contains an arbitrary serialized protocol buffer message along
        with a

        URL that describes the type of the serialized message.


        Protobuf library provides support to pack/unpack Any values in the form

        of utility functions or additional generated methods of the Any type.


        Example 1: Pack and unpack a message in C++.

            Foo foo = ...;
            Any any;
            any.PackFrom(foo);
            ...
            if (any.UnpackTo(&foo)) {
              ...
            }

        Example 2: Pack and unpack a message in Java.

            Foo foo = ...;
            Any any = Any.pack(foo);
            ...
            if (any.is(Foo.class)) {
              foo = any.unpack(Foo.class);
            }
            // or ...
            if (any.isSameTypeAs(Foo.getDefaultInstance())) {
              foo = any.unpack(Foo.getDefaultInstance());
            }

         Example 3: Pack and unpack a message in Python.

            foo = Foo(...)
            any = Any()
            any.Pack(foo)
            ...
            if any.Is(Foo.DESCRIPTOR):
              any.Unpack(foo)
              ...

         Example 4: Pack and unpack a message in Go

             foo := &pb.Foo{...}
             any, err := anypb.New(foo)
             if err != nil {
               ...
             }
             ...
             foo := &pb.Foo{}
             if err := any.UnmarshalTo(foo); err != nil {
               ...
             }

        The pack methods provided by protobuf library will by default use

        'type.googleapis.com/full.type.name' as the type URL and the unpack

        methods only use the fully qualified type name after the last '/'

        in the type URL, for example "foo.bar.com/x/y.z" will yield type

        name "y.z".


        JSON

        ====

        The JSON representation of an `Any` value uses the regular

        representation of the deserialized, embedded message, with an

        additional field `@type` which contains the type URL. Example:

            package google.profile;
            message Person {
              string first_name = 1;
              string last_name = 2;
            }

            {
              "@type": "type.googleapis.com/google.profile.Person",
              "firstName": <string>,
              "lastName": <string>
            }

        If the embedded message type is well-known and has a custom JSON

        representation, that representation will be embedded adding a field

        `value` which holds the custom JSON in addition to the `@type`

        field. Example (for message [google.protobuf.Duration][]):

            {
              "@type": "type.googleapis.com/google.protobuf.Duration",
              "value": "1.212s"
            }
    coinbase.consumer.shared.common.Amount:
      type: object
      properties:
        value:
          type: string
        currency:
          type: string
        cbrn:
          type: string
          title: >-
            CBRN Format: version:type:network:sub-network:id:sub-id

            Example:
            v1:token:solana:mainnet:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v:
      title: Message that represents the monetary amount.
    coinbase.retail.rest.proxy.fcm.FcmMarginWindowMeasure:
      type: object
      properties:
        margin_window_type:
          description: Your margin window
          allOf:
            - $ref: >-
                #/components/schemas/coinbase.retail.rest.proxy.fcm.FcmMarginWindowType
        margin_level:
          description: Margin level for liquidation purposes
          allOf:
            - $ref: >-
                #/components/schemas/coinbase.retail.rest.proxy.fcm.MarginLevelType
        initial_margin:
          type: string
          description: Initial margin
        maintenance_margin:
          type: string
          description: Maintenance margin
        liquidation_buffer:
          type: string
          description: Liquidation buffer
        total_hold:
          type: string
          description: Total Hold
        futures_buying_power:
          type: string
          description: >-
            The amount of your cash balance that is available to trade CFM
            futures
    coinbase.retail.rest.proxy.fcm.FcmMarginWindowType:
      type: string
      enum:
        - FCM_MARGIN_WINDOW_TYPE_UNSPECIFIED
        - FCM_MARGIN_WINDOW_TYPE_OVERNIGHT
        - FCM_MARGIN_WINDOW_TYPE_WEEKEND
        - FCM_MARGIN_WINDOW_TYPE_INTRADAY
        - FCM_MARGIN_WINDOW_TYPE_TRANSITION
      default: FCM_MARGIN_WINDOW_TYPE_UNSPECIFIED
    coinbase.retail.rest.proxy.fcm.MarginLevelType:
      type: string
      enum:
        - MARGIN_LEVEL_TYPE_UNSPECIFIED
        - MARGIN_LEVEL_TYPE_BASE
        - MARGIN_LEVEL_TYPE_WARNING
        - MARGIN_LEVEL_TYPE_DANGER
        - MARGIN_LEVEL_TYPE_LIQUIDATION
      default: MARGIN_LEVEL_TYPE_UNSPECIFIED
      title: margin level for liquidation purposes
  securitySchemes:
    apiKeyAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: >-
        A JWT signed using your CDP API Key Secret, encoded in base64. Refer to
        the [Creating API
        Keys](/coinbase-app/authentication-authorization/api-key-authentication)
        section of our Coinbase App Authentication docs for information on how
        to generate your Bearer Token.

````