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

# Get Perpetuals Portfolio Summary

> Get a summary of your Perpetuals portfolio



## OpenAPI

````yaml GET  /api/v3/brokerage/intx/portfolio/{portfolio_uuid}
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/intx/portfolio/{portfolio_uuid}:
    get:
      tags:
        - Perpetuals
      summary: Get Perpetuals Portfolio Summary
      description: Get a summary of your Perpetuals portfolio
      operationId: RetailBrokerageApi_GetIntxPortfolioSummary
      parameters:
        - name: portfolio_uuid
          description: The portfolio UUID.
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: A successful response.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/coinbase.retail.rest.proxy.intx.GetPortfoliosResponse
            text/event-stream:
              schema:
                $ref: >-
                  #/components/schemas/coinbase.retail.rest.proxy.intx.GetPortfoliosResponse
        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.intx.GetPortfoliosResponse:
      type: object
      properties:
        portfolios:
          type: array
          items:
            $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Portfolio'
        summary:
          allOf:
            - $ref: >-
                #/components/schemas/coinbase.retail.rest.proxy.intx.PortfoliosSummary
    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.intx.Portfolio:
      type: object
      properties:
        portfolio_uuid:
          type: string
          description: The portfolio UUID.
        collateral:
          type: string
          description: The total collateral value in USDC for the portfolio
        position_notional:
          type: string
          description: >-
            The total position notional value in USDC for all positions in the
            portfolio
        open_position_notional:
          type: string
          description: >-
            The total position notional value in USDC for all open orders and
            positions
        pending_fees:
          type: string
          description: The accrued fees that has not been paid yet in USDC
        borrow:
          type: string
          description: >-
            Total borrow amount in USDC (nets the USDC balance, position PNL,
            held USDC, accured interest and rolling debt)
        accrued_interest:
          type: string
          description: Interest charged for borrowed USDC balances
        rolling_debt:
          type: string
          description: Amount of settled transactions that hasn't been paid
        portfolio_initial_margin:
          type: string
          description: >-
            The weighted average of all the position's initial margin
            utilization
        portfolio_im_notional:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Amount'
        portfolio_maintenance_margin:
          type: string
          description: The maintenance margin of the portfolio
        portfolio_mm_notional:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Amount'
        liquidation_percentage:
          type: string
          description: The liquidation percentage of the portfolio
        liquidation_buffer:
          type: string
          description: The liquidation buffer of the portfolio
        margin_type:
          allOf:
            - $ref: '#/components/schemas/coinbase.intx_common.PortfolioMarginType'
        margin_flags:
          allOf:
            - $ref: '#/components/schemas/coinbase.intx_common.PortfolioMarginFlags'
        liquidation_status:
          allOf:
            - $ref: >-
                #/components/schemas/coinbase.intx_common.PortfolioLiquidationStatus
        unrealized_pnl:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Amount'
        total_balance:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Amount'
    coinbase.retail.rest.proxy.intx.PortfoliosSummary:
      type: object
      properties:
        unrealized_pnl:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Amount'
        buying_power:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Amount'
        total_balance:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.Amount'
        max_withdrawal_amount:
          allOf:
            - $ref: '#/components/schemas/coinbase.retail.rest.proxy.intx.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.retail.rest.proxy.intx.Amount:
      type: object
      properties:
        value:
          type: string
          description: Value of the Amount
        currency:
          type: string
          description: >-
            The currency to be allocated for the specific isolated position
            (e.g. USD, BTC, etc).
      title: Message that represents the monetary amount.
    coinbase.intx_common.PortfolioMarginType:
      type: string
      enum:
        - MARGIN_TYPE_UNSPECIFIED
        - MARGIN_TYPE_CROSS
        - MARGIN_TYPE_ISOLATED
      default: MARGIN_TYPE_UNSPECIFIED
    coinbase.intx_common.PortfolioMarginFlags:
      type: string
      enum:
        - PORTFOLIO_MARGIN_FLAGS_UNSPECIFIED
        - PORTFOLIO_MARGIN_FLAGS_IN_LIQUIDATION
      default: PORTFOLIO_MARGIN_FLAGS_UNSPECIFIED
    coinbase.intx_common.PortfolioLiquidationStatus:
      type: string
      enum:
        - PORTFOLIO_LIQUIDATION_STATUS_UNSPECIFIED
        - PORTFOLIO_LIQUIDATION_STATUS_CANCELING
        - PORTFOLIO_LIQUIDATION_STATUS_AUTO_LIQUIDATING
        - PORTFOLIO_LIQUIDATION_STATUS_LSP_ASSIGNMENT
        - PORTFOLIO_LIQUIDATION_STATUS_CUSTOMER_ASSIGNMENT
        - PORTFOLIO_LIQUIDATION_STATUS_MANUAL
        - PORTFOLIO_LIQUIDATION_STATUS_NOT_LIQUIDATING
      default: PORTFOLIO_LIQUIDATION_STATUS_UNSPECIFIED
  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.

````