# getPrice (Permit2)

GET https://api.0x.org/swap/permit2/price

Get the indicative price for a swap using Permit2 to set allowances

Reference: https://docs.0x.org/api-reference/openapi-json/swap/permit-2-getprice

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: 0x API
  version: 1.0.0
paths:
  /swap/permit2/price:
    get:
      operationId: permit-2-getprice
      summary: getPrice (Permit2)
      description: Get the indicative price for a swap using Permit2 to set allowances
      tags:
        - subpackage_swap
      parameters:
        - name: chainId
          in: query
          description: >-
            Chain ID. See
            [here](https://0x.org/docs/developer-resources/supported-chains) for
            the list of supported chains
          required: true
          schema:
            type: integer
        - name: buyToken
          in: query
          description: The contract address of the token to buy
          required: true
          schema:
            type: string
        - name: sellToken
          in: query
          description: The contract address of the token to sell
          required: true
          schema:
            type: string
        - name: sellAmount
          in: query
          description: The amount of `sellToken` in `sellToken` base units to sell
          required: true
          schema:
            type: string
        - name: taker
          in: query
          description: >-
            The address which holds the `sellToken` balance and has the
            allowance set for the swap
          required: false
          schema:
            type: string
        - name: txOrigin
          in: query
          description: >-
            The address of the external account that started the transaction.
            This is only needed if `taker` is a smart contract.
          required: false
          schema:
            type: string
        - name: recipient
          in: query
          description: >-
            The address to receive the `buyToken`. If not provided, defaults to
            the taker address. Not supported for wrap/unwrap operations.
          required: false
          schema:
            type: string
        - name: swapFeeRecipient
          in: query
          description: >-
            The wallet address to receive the specified trading fees (supports
            single or multiple comma-separated values). You must also specify
            the `swapFeeBps` in the request to use this feature. When multiple
            values are provided, must match length of `swapFeeBps`.
          required: false
          schema:
            type: string
        - name: swapFeeBps
          in: query
          description: >-
            The amount in Bps of the `swapFeeToken` to charge and deliver to the
            `swapFeeRecipient` (supports single or multiple comma-separated
            values). You must also specify the `swapFeeRecipient` in the request
            to use this feature. For security, this field has a default limit of
            1000 Bps. If your application requires a higher value, please reach
            out to us.
          required: false
          schema:
            type: string
        - name: swapFeeToken
          in: query
          description: >-
            The contract address of the token to receive trading fees in
            (supports single or multiple comma-separated values). Each token
            must be set to the value of either the `buyToken` or the
            `sellToken`. If omitted, the fee token will be determined by 0x with
            preference to stablecoins and highly liquid assets. You must also
            specify the `swapFeeRecipient` and `swapFeeBps` to charge integrator
            fees. When multiple values are provided, must match length of
            `swapFeeBps`.
          required: false
          schema:
            type: string
        - name: tradeSurplusRecipient
          in: query
          description: >-
            The address to receive any trade surplus. If specified, this address
            will receive trade surplus when applicable. Otherwise, the taker
            will receive the surplus. This feature is only available to selected
            integrators on a custom pricing plan. In other cases, the surplus
            will be collected by 0x. For assistance with a custom plan, please
            contact support.
          required: false
          schema:
            type: string
        - name: tradeSurplusMaxBps
          in: query
          description: >-
            The maximum trade surplus (positive slippage) that can be collected
            in Bps of the buy amount. If not provided, defaults to 10000 (100%).
            Must be used together with `tradeSurplusRecipient`.
          required: false
          schema:
            type: integer
        - name: gasPrice
          in: query
          description: >-
            The target gas price (in wei) for the swap transaction. If not
            provided, the default value is based on the 0x gas price oracle
          required: false
          schema:
            type: string
        - name: slippageBps
          in: query
          description: >-
            The maximum acceptable slippage of the `buyToken` in Bps. If this
            parameter is set to 0, no slippage will be tolerated. If not
            provided, the default slippage tolerance is 100Bps
          required: false
          schema:
            type: integer
            default: 100
        - name: excludedSources
          in: query
          description: >-
            Liquidity sources e.g. Uniswap_V3, SushiSwap, 0x_RFQ to exclude from
            the provided quote. See
            https://api.0x.org/sources?chainId=<chain_id> with the desired
            chain's ID for a full list of sources. Separate multiple sources
            with a comma
          required: false
          schema:
            type: string
        - name: sellEntireBalance
          in: query
          description: >-
            If set to `true`, the taker's entire `sellToken` balance will be
            sold during trade execution. The `sellAmount` should be the maximum
            estimated value, as close as possible to the actual taker's balance
            to ensure the best routing. Selling more than the `sellAmount` may
            cause the trade to revert. This feature is designed for cases where
            the precise sell amount is determined during execution. Learn more
            [here](https://0x.org/docs/0x-swap-api/advanced-topics/sell-entire-balance).
          required: false
          schema:
            $ref: >-
              #/components/schemas/SwapPermit2PriceGetParametersSellEntireBalance
        - name: 0x-api-key
          in: header
          description: Visit dashboard.0x.org to get your API Key
          required: true
          schema:
            type: string
        - name: 0x-version
          in: header
          description: API version
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Swap_permit2Getprice_Response_200'
        '400':
          description: 400 error response
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Swap::permit2::getPriceRequestBadRequestError
        '403':
          description: 403 error response
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Swap::permit2::getPriceRequestForbiddenError
        '422':
          description: 422 error response
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Swap::permit2::getPriceRequestUnprocessableEntityError
        '500':
          description: 500 error response
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/Swap::permit2::getPriceRequestInternalServerError
servers:
  - url: https://api.0x.org
components:
  schemas:
    SwapPermit2PriceGetParametersSellEntireBalance:
      type: string
      enum:
        - 'true'
        - 'false'
      default: 'false'
      title: SwapPermit2PriceGetParametersSellEntireBalance
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeeType:
      type: string
      enum:
        - volume
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeeType
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFee:
      type: object
      properties:
        amount:
          type: string
          description: The amount of token charged as the integrator fee
        token:
          type: string
          description: The address of the token charged as the integrator fee
        type:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeeType
      required:
        - amount
        - token
        - type
      description: The specified fee to charge and deliver to the `swapFeeRecipient`.
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFee
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeesItemsType:
      type: string
      enum:
        - volume
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeesItemsType
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeesItems:
      type: object
      properties:
        amount:
          type: string
          description: The amount of token charged as the integrator fee
        token:
          type: string
          description: The address of the token charged as the integrator fee
        type:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeesItemsType
      required:
        - amount
        - token
        - type
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeesItems
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesZeroExFeeType:
      type: string
      enum:
        - volume
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesZeroExFeeType
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesZeroExFee:
      type: object
      properties:
        amount:
          type: string
          description: The amount of token charged as the 0x fee
        token:
          type: string
          description: The address of the token charged as the 0x fee
        type:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesZeroExFeeType
      required:
        - amount
        - token
        - type
      description: The fee charged by 0x for the trade.
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesZeroExFee
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesGasFeeType:
      type: string
      enum:
        - gas
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesGasFeeType
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesGasFee:
      type: object
      properties:
        amount:
          type: string
          description: The amount of token charged as the gas fee
        token:
          type: string
          description: The address of the token charged as the gas fee
        type:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesGasFeeType
      required:
        - amount
        - token
        - type
      description: The gas fee to be used in submitting the transaction.
      title: SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesGasFee
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Fees:
      type: object
      properties:
        integratorFee:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFee
            - type: 'null'
          description: The specified fee to charge and deliver to the `swapFeeRecipient`.
        integratorFees:
          type:
            - array
            - 'null'
          items:
            $ref: >-
              #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesIntegratorFeesItems
          description: The specified fees to charge and deliver to the `swapFeesRecipient`.
        zeroExFee:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesZeroExFee
            - type: 'null'
          description: The fee charged by 0x for the trade.
        gasFee:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0FeesGasFee
            - type: 'null'
          description: The gas fee to be used in submitting the transaction.
      required:
        - integratorFee
        - integratorFees
        - zeroExFee
        - gasFee
      description: >-
        Fees to be deducted in this transaction. It contains the
        `integratorFee`, `zeroExFee` and `gasFee`
      title: SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Fees
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Gas:
      type: object
      properties: {}
      description: >-
        The estimated gas limit that should be used to send the transaction to
        guarantee settlement
      title: SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Gas
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0IssuesAllowance:
      type: object
      properties:
        actual:
          type: string
          description: The `taker`'s current allowance of the `spender`
        spender:
          type: string
          description: The address to set the allowance on
      required:
        - actual
        - spender
      description: >-
        Details of allowances that the `taker` must set for in order to execute
        the swap successfully. Null if no allowance is required
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0IssuesAllowance
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0IssuesBalance:
      type: object
      properties:
        token:
          type: string
          description: The contract address of the `sellToken`
        actual:
          type: string
          description: The current balance of the `sellToken` in the `taker` address
        expected:
          type: string
          description: >-
            The balance of the `sellToken` required for the swap to execute
            successfully
      required:
        - token
        - actual
        - expected
      description: >-
        Details of balance of the `sellToken` that the `taker` must hold. Null
        if the `taker` has sufficient balance
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0IssuesBalance
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Issues:
      type: object
      properties:
        allowance:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0IssuesAllowance
            - type: 'null'
          description: >-
            Details of allowances that the `taker` must set for in order to
            execute the swap successfully. Null if no allowance is required
        balance:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0IssuesBalance
            - type: 'null'
          description: >-
            Details of balance of the `sellToken` that the `taker` must hold.
            Null if the `taker` has sufficient balance
        simulationIncomplete:
          type: boolean
          description: >-
            This is set to `true` when 0x cannot validate the transaction. This
            happens when the `taker` has an insufficient balance of the
            `sellToken` and 0x is unable to peform ehanced quote validation with
            the low balance. Note that this does not necessarily mean that the
            trade will revert
        invalidSourcesPassed:
          type: array
          items:
            type: string
          description: >-
            A list of invalid sources present in `excludedSources` request. See
            https://api.0x.org/sources?chainId= with the desired chain's ID for
            the list of valid sources
      required:
        - allowance
        - balance
        - simulationIncomplete
        - invalidSourcesPassed
      description: >-
        An object containing potential issues discovered during 0x validation
        that can prevent the swap from being executed successfully by the
        `taker`
      title: SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Issues
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0RouteFillsItems:
      type: object
      properties:
        from:
          type: string
          description: The contract address of the input token
        to:
          type: string
          description: The contract address of the output token
        source:
          type: string
          description: The liquidity source used in the route
        proportionBps:
          type: string
          description: The proportion of the trade to be filled by the `source`
      required:
        - from
        - to
        - source
        - proportionBps
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0RouteFillsItems
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0RouteTokensItems:
      type: object
      properties:
        address:
          type: string
          description: The token address. This is the unique identifier of the token
        symbol:
          type: string
          description: >-
            The token symbol. This is not guaranteed to be unique, as multiple
            tokens can have the same symbol
      required:
        - address
        - symbol
      description: Properties of the tokens involved in the swap
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0RouteTokensItems
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Route:
      type: object
      properties:
        fills:
          type: array
          items:
            $ref: >-
              #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0RouteFillsItems
          description: Details of each segment that 0x routes the swap through
        tokens:
          type: array
          items:
            $ref: >-
              #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0RouteTokensItems
          description: Properties of the tokens involved in the swap
      required:
        - fills
        - tokens
      description: The path of liquidity sources to be used in executing this swap
      title: SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Route
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenBuyTaxBps:
      type: object
      properties: {}
      description: >-
        The buy tax in bps of the token. Since each token could have arbitrary
        implementation, this field is best effort, meaning it would be set to
        `null` if the system is not able to determine the tax
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenBuyTaxBps
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenSellTaxBps:
      type: object
      properties: {}
      description: >-
        The sell tax in bps of the token. Since each token could have arbitrary
        implementation, this field is best effort, meaning it would be set to
        `null` if the system is not able to determine the tax
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenSellTaxBps
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenTransferTaxBps:
      type: object
      properties: {}
      description: >-
        The transfer tax in bps of the token. Since each token could have
        arbitrary implementation, this field is best effort, meaning it would be
        set to `null` if the system is not able to determine the tax
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenTransferTaxBps
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyToken:
      type: object
      properties:
        buyTaxBps:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenBuyTaxBps
            - type: 'null'
          description: >-
            The buy tax in bps of the token. Since each token could have
            arbitrary implementation, this field is best effort, meaning it
            would be set to `null` if the system is not able to determine the
            tax
        sellTaxBps:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenSellTaxBps
            - type: 'null'
          description: >-
            The sell tax in bps of the token. Since each token could have
            arbitrary implementation, this field is best effort, meaning it
            would be set to `null` if the system is not able to determine the
            tax
        transferTaxBps:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyTokenTransferTaxBps
            - type: 'null'
          description: >-
            The transfer tax in bps of the token. Since each token could have
            arbitrary implementation, this field is best effort, meaning it
            would be set to `null` if the system is not able to determine the
            tax
      required:
        - buyTaxBps
        - sellTaxBps
        - transferTaxBps
      description: Swap-related metadata for the buy token
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyToken
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenBuyTaxBps:
      type: object
      properties: {}
      description: >-
        The buy tax in bps of the token. Since each token could have arbitrary
        implementation, this field is best effort, meaning it would be set to
        `null` if the system is not able to determine the tax
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenBuyTaxBps
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenSellTaxBps:
      type: object
      properties: {}
      description: >-
        The sell tax in bps of the token. Since each token could have arbitrary
        implementation, this field is best effort, meaning it would be set to
        `null` if the system is not able to determine the tax
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenSellTaxBps
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenTransferTaxBps:
      type: object
      properties: {}
      description: >-
        The transfer tax in bps of the token. Since each token could have
        arbitrary implementation, this field is best effort, meaning it would be
        set to `null` if the system is not able to determine the tax
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenTransferTaxBps
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellToken:
      type: object
      properties:
        buyTaxBps:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenBuyTaxBps
            - type: 'null'
          description: >-
            The buy tax in bps of the token. Since each token could have
            arbitrary implementation, this field is best effort, meaning it
            would be set to `null` if the system is not able to determine the
            tax
        sellTaxBps:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenSellTaxBps
            - type: 'null'
          description: >-
            The sell tax in bps of the token. Since each token could have
            arbitrary implementation, this field is best effort, meaning it
            would be set to `null` if the system is not able to determine the
            tax
        transferTaxBps:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellTokenTransferTaxBps
            - type: 'null'
          description: >-
            The transfer tax in bps of the token. Since each token could have
            arbitrary implementation, this field is best effort, meaning it
            would be set to `null` if the system is not able to determine the
            tax
      required:
        - buyTaxBps
        - sellTaxBps
        - transferTaxBps
      description: Swap-related metadata for the sell token
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellToken
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadata:
      type: object
      properties:
        buyToken:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataBuyToken
          description: Swap-related metadata for the buy token
        sellToken:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadataSellToken
          description: Swap-related metadata for the sell token
      required:
        - buyToken
        - sellToken
      description: Swap-related metadata for the buy and sell token in the swap
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadata
    SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TotalNetworkFee:
      type: object
      properties: {}
      description: >-
        The estimated total network cost of the swap. On chains where there is
        no L1 data cost, it is calculated as `gas` * `gasPrice`. On chains where
        there is an L1 data cost, it is calculated as `gas` * `gasPrice` + L1
        data cost.
      title: >-
        SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TotalNetworkFee
    SwapPermit2GetpriceResponse2000:
      type: object
      properties:
        allowanceTarget:
          type:
            - string
            - 'null'
          description: >-
            The target contract address for which the `taker` needs to have an
            allowance in order to be able to complete the swap. For swaps with
            the native asset (ie "ETH" or "BNB") as the `sellToken`, wrapping
            the native asset (i.e. "ETH" to "WETH") or unwrapping, no allowance
            is needed
        blockNumber:
          type: string
          description: >-
            The block number at which the liquidity sources were sampled to
            generate the quote. This indicates the freshness of the quote
        buyAmount:
          type: string
          description: >-
            The amount of `buyToken` (in `buyToken` units) that will be bought
            in the swap
        buyToken:
          type: string
          description: The contract address of the token to buy in the swap
        fees:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Fees
          description: >-
            Fees to be deducted in this transaction. It contains the
            `integratorFee`, `zeroExFee` and `gasFee`
        gas:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Gas
            - type: 'null'
          description: >-
            The estimated gas limit that should be used to send the transaction
            to guarantee settlement
        gasPrice:
          type: string
          description: >-
            The gas price (in wei) that should be used to send the transaction.
            The transaction needs to be sent with this `gasPrice` for the
            transaction to be successful
        issues:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Issues
          description: >-
            An object containing potential issues discovered during 0x
            validation that can prevent the swap from being executed
            successfully by the `taker`
        liquidityAvailable:
          type: boolean
          description: >-
            This validates the availability of liquidity for the quote
            requested. The rest of the fields will only be returned if `true`
        minBuyAmount:
          type: string
          description: >-
            The price which must be met or else the entire transaction will
            revert. This price is influenced by the `slippageBps` parameter.
            On-chain sources may encounter price movements from quote to
            settlement
        route:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0Route
          description: The path of liquidity sources to be used in executing this swap
        sellAmount:
          type: string
          description: >-
            The amount of `sellToken` (in `sellToken` units) that will be sold
            in this swap
        sellToken:
          type: string
          description: The contract address of the token to sell in the swap
        tokenMetadata:
          $ref: >-
            #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TokenMetadata
          description: Swap-related metadata for the buy and sell token in the swap
        totalNetworkFee:
          oneOf:
            - $ref: >-
                #/components/schemas/SwapPermit2PriceGetResponsesContentApplicationJsonSchemaOneOf0TotalNetworkFee
            - type: 'null'
          description: >-
            The estimated total network cost of the swap. On chains where there
            is no L1 data cost, it is calculated as `gas` * `gasPrice`. On
            chains where there is an L1 data cost, it is calculated as `gas` *
            `gasPrice` + L1 data cost.
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - allowanceTarget
        - blockNumber
        - buyAmount
        - buyToken
        - fees
        - gas
        - gasPrice
        - issues
        - liquidityAvailable
        - minBuyAmount
        - route
        - sellAmount
        - sellToken
        - tokenMetadata
        - totalNetworkFee
        - zid
      title: SwapPermit2GetpriceResponse2000
    SwapPermit2GetpriceResponse2001:
      type: object
      properties:
        liquidityAvailable:
          type: boolean
          description: >-
            This validates the availability of liquidity for the quote
            requested. No other fields will be returned if it is `false`
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - liquidityAvailable
        - zid
      title: SwapPermit2GetpriceResponse2001
    Swap_permit2Getprice_Response_200:
      oneOf:
        - $ref: '#/components/schemas/SwapPermit2GetpriceResponse2000'
        - $ref: '#/components/schemas/SwapPermit2GetpriceResponse2001'
      title: Swap_permit2Getprice_Response_200
    InputInvalidName:
      type: string
      enum:
        - INPUT_INVALID
      title: InputInvalidName
    InputInvalidDataDetailsItems:
      type: object
      properties:
        field:
          type: string
          description: The input field name
        reason:
          type: string
          description: The validation failure reason
      required:
        - field
        - reason
      title: InputInvalidDataDetailsItems
    InputInvalidData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
        details:
          type: array
          items:
            $ref: '#/components/schemas/InputInvalidDataDetailsItems'
          description: The list of invalid inputs
      required:
        - zid
        - details
      title: InputInvalidData
    INPUT_INVALID:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/InputInvalidName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/InputInvalidData'
      required:
        - name
        - message
        - data
      title: INPUT_INVALID
    RecipientNotSupportedName:
      type: string
      enum:
        - RECIPIENT_NOT_SUPPORTED
      title: RecipientNotSupportedName
    RecipientNotSupportedData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: RecipientNotSupportedData
    RECIPIENT_NOT_SUPPORTED:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/RecipientNotSupportedName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/RecipientNotSupportedData'
      required:
        - name
        - message
        - data
      title: RECIPIENT_NOT_SUPPORTED
    SwapValidationFailedName:
      type: string
      enum:
        - SWAP_VALIDATION_FAILED
      title: SwapValidationFailedName
    SwapValidationFailedData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: SwapValidationFailedData
    SWAP_VALIDATION_FAILED:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/SwapValidationFailedName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/SwapValidationFailedData'
      required:
        - name
        - message
        - data
      title: SWAP_VALIDATION_FAILED
    TokenNotSupportedName:
      type: string
      enum:
        - TOKEN_NOT_SUPPORTED
      title: TokenNotSupportedName
    TokenNotSupportedData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: TokenNotSupportedData
    TOKEN_NOT_SUPPORTED:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/TokenNotSupportedName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/TokenNotSupportedData'
      required:
        - name
        - message
        - data
      title: TOKEN_NOT_SUPPORTED
    UserNotAuthorizedName:
      type: string
      enum:
        - USER_NOT_AUTHORIZED
      title: UserNotAuthorizedName
    UserNotAuthorizedData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: UserNotAuthorizedData
    USER_NOT_AUTHORIZED:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/UserNotAuthorizedName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/UserNotAuthorizedData'
      required:
        - name
        - message
        - data
      title: USER_NOT_AUTHORIZED
    Swap::permit2::getPriceRequestBadRequestError:
      oneOf:
        - $ref: '#/components/schemas/INPUT_INVALID'
        - $ref: '#/components/schemas/RECIPIENT_NOT_SUPPORTED'
        - $ref: '#/components/schemas/SWAP_VALIDATION_FAILED'
        - $ref: '#/components/schemas/TOKEN_NOT_SUPPORTED'
        - $ref: '#/components/schemas/USER_NOT_AUTHORIZED'
      title: Swap::permit2::getPriceRequestBadRequestError
    TakerNotAuthorizedForTradeName:
      type: string
      enum:
        - TAKER_NOT_AUTHORIZED_FOR_TRADE
      title: TakerNotAuthorizedForTradeName
    TakerNotAuthorizedForTradeData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: TakerNotAuthorizedForTradeData
    TAKER_NOT_AUTHORIZED_FOR_TRADE:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/TakerNotAuthorizedForTradeName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/TakerNotAuthorizedForTradeData'
      required:
        - name
        - message
        - data
      title: TAKER_NOT_AUTHORIZED_FOR_TRADE
    RecipientNotAuthorizedForTradeName:
      type: string
      enum:
        - RECIPIENT_NOT_AUTHORIZED_FOR_TRADE
      title: RecipientNotAuthorizedForTradeName
    RecipientNotAuthorizedForTradeData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: RecipientNotAuthorizedForTradeData
    RECIPIENT_NOT_AUTHORIZED_FOR_TRADE:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/RecipientNotAuthorizedForTradeName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/RecipientNotAuthorizedForTradeData'
      required:
        - name
        - message
        - data
      title: RECIPIENT_NOT_AUTHORIZED_FOR_TRADE
    XstocksNotAuthorizedName:
      type: string
      enum:
        - XSTOCKS_NOT_AUTHORIZED
      title: XstocksNotAuthorizedName
    XstocksNotAuthorizedData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: XstocksNotAuthorizedData
    XSTOCKS_NOT_AUTHORIZED:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/XstocksNotAuthorizedName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/XstocksNotAuthorizedData'
      required:
        - name
        - message
        - data
      title: XSTOCKS_NOT_AUTHORIZED
    Swap::permit2::getPriceRequestForbiddenError:
      oneOf:
        - $ref: '#/components/schemas/TAKER_NOT_AUTHORIZED_FOR_TRADE'
        - $ref: '#/components/schemas/RECIPIENT_NOT_AUTHORIZED_FOR_TRADE'
        - $ref: '#/components/schemas/XSTOCKS_NOT_AUTHORIZED'
      title: Swap::permit2::getPriceRequestForbiddenError
    BuyTokenNotAuthorizedForTradeName:
      type: string
      enum:
        - BUY_TOKEN_NOT_AUTHORIZED_FOR_TRADE
      title: BuyTokenNotAuthorizedForTradeName
    BuyTokenNotAuthorizedForTradeData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: BuyTokenNotAuthorizedForTradeData
    BUY_TOKEN_NOT_AUTHORIZED_FOR_TRADE:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/BuyTokenNotAuthorizedForTradeName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/BuyTokenNotAuthorizedForTradeData'
      required:
        - name
        - message
        - data
      title: BUY_TOKEN_NOT_AUTHORIZED_FOR_TRADE
    SellTokenNotAuthorizedForTradeName:
      type: string
      enum:
        - SELL_TOKEN_NOT_AUTHORIZED_FOR_TRADE
      title: SellTokenNotAuthorizedForTradeName
    SellTokenNotAuthorizedForTradeData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: SellTokenNotAuthorizedForTradeData
    SELL_TOKEN_NOT_AUTHORIZED_FOR_TRADE:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/SellTokenNotAuthorizedForTradeName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/SellTokenNotAuthorizedForTradeData'
      required:
        - name
        - message
        - data
      title: SELL_TOKEN_NOT_AUTHORIZED_FOR_TRADE
    Swap::permit2::getPriceRequestUnprocessableEntityError:
      oneOf:
        - $ref: '#/components/schemas/BUY_TOKEN_NOT_AUTHORIZED_FOR_TRADE'
        - $ref: '#/components/schemas/SELL_TOKEN_NOT_AUTHORIZED_FOR_TRADE'
      title: Swap::permit2::getPriceRequestUnprocessableEntityError
    InternalServerErrorName:
      type: string
      enum:
        - INTERNAL_SERVER_ERROR
      title: InternalServerErrorName
    InternalServerErrorData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: InternalServerErrorData
    INTERNAL_SERVER_ERROR:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/InternalServerErrorName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/InternalServerErrorData'
      required:
        - name
        - message
        - data
      title: INTERNAL_SERVER_ERROR
    UncategorizedName:
      type: string
      enum:
        - UNCATEGORIZED
      title: UncategorizedName
    UncategorizedData:
      type: object
      properties:
        zid:
          type: string
          description: The unique ZeroEx identifier of the request
      required:
        - zid
      title: UncategorizedData
    UNCATEGORIZED:
      type: object
      properties:
        name:
          $ref: '#/components/schemas/UncategorizedName'
        message:
          type: string
        data:
          $ref: '#/components/schemas/UncategorizedData'
      required:
        - name
        - message
        - data
      title: UNCATEGORIZED
    Swap::permit2::getPriceRequestInternalServerError:
      oneOf:
        - $ref: '#/components/schemas/INTERNAL_SERVER_ERROR'
        - $ref: '#/components/schemas/UNCATEGORIZED'
      title: Swap::permit2::getPriceRequestInternalServerError

```

## SDK Code Examples

```python
import requests

url = "https://api.0x.org/swap/permit2/price"

querystring = {"chainId":"1","buyToken":"0xdac17f958d2ee523a2206206994597c13d831ec7","sellToken":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","sellAmount":"100000000","taker":"0x70a9f34f9b34c64957b9c401a97bfed35b95049e"}

payload = { "body": {
        "chainId": 1,
        "buyToken": "0xdac17f958d2ee523a2206206994597c13d831ec7",
        "sellToken": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
        "sellAmount": "100000000",
        "taker": "0x70a9f34f9b34c64957b9c401a97bfed35b95049e",
        "0x-api-key": "your-api-key-here",
        "0x-version": "v2"
    } }
headers = {
    "0x-api-key": "0x-api-key",
    "0x-version": "v2",
    "Content-Type": "application/json"
}

response = requests.get(url, json=payload, headers=headers, params=querystring)

print(response.json())
```

```javascript
const url = 'https://api.0x.org/swap/permit2/price?chainId=1&buyToken=0xdac17f958d2ee523a2206206994597c13d831ec7&sellToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&sellAmount=100000000&taker=0x70a9f34f9b34c64957b9c401a97bfed35b95049e';
const options = {
  method: 'GET',
  headers: {
    '0x-api-key': '0x-api-key',
    '0x-version': 'v2',
    'Content-Type': 'application/json'
  },
  body: '{"body":{"chainId":1,"buyToken":"0xdac17f958d2ee523a2206206994597c13d831ec7","sellToken":"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48","sellAmount":"100000000","taker":"0x70a9f34f9b34c64957b9c401a97bfed35b95049e","0x-api-key":"your-api-key-here","0x-version":"v2"}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.0x.org/swap/permit2/price?chainId=1&buyToken=0xdac17f958d2ee523a2206206994597c13d831ec7&sellToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&sellAmount=100000000&taker=0x70a9f34f9b34c64957b9c401a97bfed35b95049e"

	payload := strings.NewReader("{\n  \"body\": {\n    \"chainId\": 1,\n    \"buyToken\": \"0xdac17f958d2ee523a2206206994597c13d831ec7\",\n    \"sellToken\": \"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\n    \"sellAmount\": \"100000000\",\n    \"taker\": \"0x70a9f34f9b34c64957b9c401a97bfed35b95049e\",\n    \"0x-api-key\": \"your-api-key-here\",\n    \"0x-version\": \"v2\"\n  }\n}")

	req, _ := http.NewRequest("GET", url, payload)

	req.Header.Add("0x-api-key", "0x-api-key")
	req.Header.Add("0x-version", "v2")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.0x.org/swap/permit2/price?chainId=1&buyToken=0xdac17f958d2ee523a2206206994597c13d831ec7&sellToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&sellAmount=100000000&taker=0x70a9f34f9b34c64957b9c401a97bfed35b95049e")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["0x-api-key"] = '0x-api-key'
request["0x-version"] = 'v2'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"body\": {\n    \"chainId\": 1,\n    \"buyToken\": \"0xdac17f958d2ee523a2206206994597c13d831ec7\",\n    \"sellToken\": \"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\n    \"sellAmount\": \"100000000\",\n    \"taker\": \"0x70a9f34f9b34c64957b9c401a97bfed35b95049e\",\n    \"0x-api-key\": \"your-api-key-here\",\n    \"0x-version\": \"v2\"\n  }\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.0x.org/swap/permit2/price?chainId=1&buyToken=0xdac17f958d2ee523a2206206994597c13d831ec7&sellToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&sellAmount=100000000&taker=0x70a9f34f9b34c64957b9c401a97bfed35b95049e")
  .header("0x-api-key", "0x-api-key")
  .header("0x-version", "v2")
  .header("Content-Type", "application/json")
  .body("{\n  \"body\": {\n    \"chainId\": 1,\n    \"buyToken\": \"0xdac17f958d2ee523a2206206994597c13d831ec7\",\n    \"sellToken\": \"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\n    \"sellAmount\": \"100000000\",\n    \"taker\": \"0x70a9f34f9b34c64957b9c401a97bfed35b95049e\",\n    \"0x-api-key\": \"your-api-key-here\",\n    \"0x-version\": \"v2\"\n  }\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.0x.org/swap/permit2/price?chainId=1&buyToken=0xdac17f958d2ee523a2206206994597c13d831ec7&sellToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&sellAmount=100000000&taker=0x70a9f34f9b34c64957b9c401a97bfed35b95049e', [
  'body' => '{
  "body": {
    "chainId": 1,
    "buyToken": "0xdac17f958d2ee523a2206206994597c13d831ec7",
    "sellToken": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "sellAmount": "100000000",
    "taker": "0x70a9f34f9b34c64957b9c401a97bfed35b95049e",
    "0x-api-key": "your-api-key-here",
    "0x-version": "v2"
  }
}',
  'headers' => [
    '0x-api-key' => '0x-api-key',
    '0x-version' => 'v2',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.0x.org/swap/permit2/price?chainId=1&buyToken=0xdac17f958d2ee523a2206206994597c13d831ec7&sellToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&sellAmount=100000000&taker=0x70a9f34f9b34c64957b9c401a97bfed35b95049e");
var request = new RestRequest(Method.GET);
request.AddHeader("0x-api-key", "0x-api-key");
request.AddHeader("0x-version", "v2");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"body\": {\n    \"chainId\": 1,\n    \"buyToken\": \"0xdac17f958d2ee523a2206206994597c13d831ec7\",\n    \"sellToken\": \"0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48\",\n    \"sellAmount\": \"100000000\",\n    \"taker\": \"0x70a9f34f9b34c64957b9c401a97bfed35b95049e\",\n    \"0x-api-key\": \"your-api-key-here\",\n    \"0x-version\": \"v2\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "0x-api-key": "0x-api-key",
  "0x-version": "v2",
  "Content-Type": "application/json"
]
let parameters = ["body": [
    "chainId": 1,
    "buyToken": "0xdac17f958d2ee523a2206206994597c13d831ec7",
    "sellToken": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
    "sellAmount": "100000000",
    "taker": "0x70a9f34f9b34c64957b9c401a97bfed35b95049e",
    "0x-api-key": "your-api-key-here",
    "0x-version": "v2"
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.0x.org/swap/permit2/price?chainId=1&buyToken=0xdac17f958d2ee523a2206206994597c13d831ec7&sellToken=0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48&sellAmount=100000000&taker=0x70a9f34f9b34c64957b9c401a97bfed35b95049e")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```