> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.getsinbad.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.getsinbad.com/_mcp/server.

# Get a trade breakdown

GET https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/{breakdownId}

Get a trade breakdown.

**Credential:** Customer session

**Before you call**

- A customer session for the same partner, integration, customer, wallet and chain.
- An active saved account matching the catalog payment method.
- A registered customer wallet and supported chain.

Reads a breakdown that belongs to the authenticated customer's partner, integration, wallet and chain. The response contains the stored pricing and status. It never reprices a breakdown or extends its deadline.

Funding status is independent of transaction jobs. `AWAITING_FUNDING` can remain after the signing deadline while Sinbad catches up on confirmed blocks, and `EXPIRED` is reported only once Sinbad has checked the chain past that deadline. Poll this endpoint even if you never submitted a transaction hash.

A breakdown that a newer request replaced returns `409 CONFLICT`, unless its escrow transaction funded anyway. In that case the call returns `CONFIRMED` with the original pricing and no `escrowTransaction` or approval transactions to sign.



> Confirm with Sinbad that this endpoint is enabled in your environment.

**Errors**

| Status | Code | What to do |
| --- | --- | --- |
| 400 | `VALIDATION_ERROR` | Correct the fields reported in details before retrying. |
| 401 | `UNAUTHENTICATED` | Create a new customer session or use a valid server credential. |
| 403 | `FORBIDDEN` | Check credential ownership, integration and the supplied Origin. |
| 404 | `NOT_FOUND` | Check the resource ID. A resource that belongs to someone else also returns 404. |
| 409 | `CONFLICT` | Read the current state again before you prepare or retry. |
| 503 | `UPSTREAM_ERROR` | Retry with backoff; preserve the same idempotency key for a repeated mutation. |

Reference: https://docs.getsinbad.com/api-reference/offers-and-breakdowns/get-trade-breakdown

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `breakdownId` (string, required)

## Response

### 200

Financial breakdown, prepared escrow call, approval state and current submission status.

- `merchant` (offers_quotes__MerchantDisplay, required) — Offer values are current observations; breakdown POST, GET and retries return the same creation snapshot.
- `breakdownId` (string, required)
- `createdAt` (datetime, required)
- `expiresAt` (datetime, required) — Fresh breakdown creation plus 300 seconds.
- `serverTime` (datetime, required)
- `side` (enum, required)
  - Allowed values: `BUY`, `SELL`
- `status` (enum, required) — Confirmed escrow outcome, independent of optional transaction tracking.
  - Allowed values: `AWAITING_FUNDING`, `CONFIRMED`, `EXPIRED`, `REVIEW_REQUIRED`
- `tradeId` (string, required, nullable)
- `tradeDetails` (OffersQuotesTradeBreakdownTradeDetails, required) — Send exactly one of: `YouPay`, or `YouReceive`.
- `merchantRateDetails` (OffersQuotesTradeBreakdownMerchantRateDetails, required)
- `fiatCurrency` (offers_quotes__FiatCurrency, required)
- `paymentMethod` (offers_quotes__SafePaymentMethod, required)
- `submission` (OffersQuotesTradeBreakdownSubmission, required, nullable)
- `escrowTransaction` (OffersQuotesTradeBreakdownEscrowTransaction, optional) — Use this escrow call after approvals confirm. Nonce/gas/fees are populated by the signer, not pinned before approval.
- `approvalRequired` (boolean, optional) — Allowance when the breakdown was created. Sinbad rechecks it when you submit.
- `approval` (OffersQuotesTradeBreakdownApproval, optional)

## Errors

### 400 Bad Request Error

The request is invalid.

- `error` (V1TradeBreakdownsBreakdownIdGetResponsesContentApplicationJsonSchemaError, required)

### 401 Unauthorized Error

Authentication is required.

- `error` (V1TradeBreakdownsBreakdownIdGetResponsesContentApplicationJsonSchemaError, required)

### 403 Forbidden Error

You do not have permission to perform this action.

- `error` (V1TradeBreakdownsBreakdownIdGetResponsesContentApplicationJsonSchemaError, required)

### 404 Not Found Error

The requested resource was not found.

- `error` (V1TradeBreakdownsBreakdownIdGetResponsesContentApplicationJsonSchemaError, required)

### 409 Conflict Error

The request conflicts with the current state of the resource.

- `error` (V1TradeBreakdownsBreakdownIdGetResponsesContentApplicationJsonSchemaError, required)

### 503 Service Unavailable Error

Service temporarily unavailable.

- `error` (V1TradeBreakdownsBreakdownIdGetResponsesContentApplicationJsonSchemaError, required)

## Types

### offers_quotes__MerchantDisplay

Offer values are current observations; breakdown POST, GET and retries return the same creation snapshot.

- `fullName` (string, required, nullable)
- `avatarUrl` (string, required, nullable)
- `username` (string, required, nullable)
- `ratingPercent` (double, required, nullable) — Null when no valid rating is available.
- `tradeCount` (integer, required)
- `isSuperMerchant` (boolean, required)
- `experienceYears` (integer, required) — Native display parity; floor of experienceDays divided by 365 with a minimum and fallback of one.

### OffersQuotesTradeBreakdownTradeDetails

Send exactly one of: `YouPay`, or `YouReceive`.

- `Amount` (offers_quotes__DisplayValue, required)
- `MerchantRate` (offers_quotes__DisplayValue, required)
- `Subtotal` (offers_quotes__DisplayValue, required)
- `ServiceFee` (offers_quotes__DisplayValue, required)
- `YouPay` (offers_quotes__DisplayValue, optional)
- `YouReceive` (offers_quotes__DisplayValue, optional)

### OffersQuotesTradeBreakdownMerchantRateDetails

- `MarketRate` (offers_quotes__DisplayValue, required)
- `MerchantMargin` (offers_quotes__DisplayValue, required)
- `MerchantRate` (offers_quotes__DisplayValue, required)

### offers_quotes__FiatCurrency

- `id` (string, required)
- `code` (string, required)
- `name` (string, required)
- `symbol` (string, required)
- `decimals` (integer, required)

### offers_quotes__SafePaymentMethod

- `paymentMethodId` (string, required)
- `displayLabel` (string, required) — Catalog-provided name, never a private account label.
- `isActive` (boolean, required)
- `_logoURL` (string, required)
- `id` (string, optional) — Customer saved account ID; omitted for catalog summaries.

### OffersQuotesTradeBreakdownSubmission

- `status` (string, required)
- `transactionHash` (string, required)
- `purpose` (string, required)
- `confirmations` (integer, required)
- `requiredConfirmations` (integer, required)

### OffersQuotesTradeBreakdownEscrowTransaction

Use this escrow call after approvals confirm. Nonce/gas/fees are populated by the signer, not pinned before approval.

- OffersQuotesTradeBreakdownEscrowTransaction0
- map from string to any

### OffersQuotesTradeBreakdownApproval

- OffersQuotesTradeBreakdownApproval0
- map from string to any

### V1TradeBreakdownsBreakdownIdGetResponsesContentApplicationJsonSchemaError

- `code` (string, required)
- `numericId` (integer, required)
- `message` (string, required)
- `requestId` (string, optional)
- `details` (map from string to any, optional)

### offers_quotes__DisplayValue

- `value` (double, required) — Display only; exact pricing strings govern execution.
- `type` (enum, required)
  - Allowed values: `fiat`, `crypto`, `percentage`

### OffersQuotesTradeBreakdownEscrowTransaction0

- `preparationId` (string, required)
- `purpose` (enum, required)
  - Allowed values: `approval`, `approvalReset`, `createEscrow`, `markPaid`, `release`, `cancelPrePaid`, `openDispute`, `mutualResolveDispute`
- `chainId` (integer, required)
- `from` (string, required)
- `to` (string, required)
- `data` (string, required)
- `value` (enum, required)
  - Allowed values: `0`
- `expiresAt` (datetime, required, nullable) — Null for lifecycle actions; checkout calls retain their fixed funding deadline.

### OffersQuotesTradeBreakdownApproval0

- `required` (boolean, required)
- `tokenAddress` (string, required)
- `spender` (string, required)
- `requiredAmount` (string, required) — Required allowance in atomic token units (USDT has 6 decimals).
- `allowance` (string, required) — Observed allowance in atomic token units.

## Examples

**Response**

```json
{
  "merchant": {
    "fullName": "Demo merchant",
    "avatarUrl": "https://example.com/avatar.png",
    "username": "demo_merchant",
    "ratingPercent": 98,
    "tradeCount": 1240,
    "isSuperMerchant": true,
    "experienceYears": 3
  },
  "breakdownId": "breakdown_demo",
  "createdAt": "2026-10-23T10:00:00.000Z",
  "expiresAt": "2026-10-23T10:05:00.000Z",
  "serverTime": "2026-10-23T10:00:00.000Z",
  "side": "BUY",
  "status": "AWAITING_FUNDING",
  "tradeId": null,
  "tradeDetails": {
    "Amount": {
      "value": 100,
      "type": "crypto"
    },
    "MerchantRate": {
      "value": 1,
      "type": "fiat"
    },
    "Subtotal": {
      "value": 100,
      "type": "fiat"
    },
    "ServiceFee": {
      "value": 0,
      "type": "fiat"
    },
    "YouPay": {
      "value": 100,
      "type": "fiat"
    }
  },
  "merchantRateDetails": {
    "MarketRate": {
      "value": 1,
      "type": "fiat"
    },
    "MerchantMargin": {
      "value": 0,
      "type": "percentage"
    },
    "MerchantRate": {
      "value": 1,
      "type": "fiat"
    }
  },
  "fiatCurrency": {
    "id": "usd",
    "code": "USD",
    "name": "US Dollar",
    "symbol": "$",
    "decimals": 2
  },
  "paymentMethod": {
    "paymentMethodId": "bank_transfer",
    "displayLabel": "Bank transfer",
    "isActive": true,
    "_logoURL": "",
    "id": "account_demo"
  },
  "submission": null,
  "escrowTransaction": {
    "chainId": 80002,
    "data": "0x96f5f7d4cd8bdc71c97deb8b806e60f4592418d63f87a7d064f8a848e1cac1012c43280ffdf1c2b36f2ea80f9cc1a9bb5aed70dbd50cba3db1f3d9e742e5687cb228970b0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000222222222222222222222222222222222222222200000000000000000000000019e7e376e7c213b7e7e7e46cc70a5dd086daff2a00000000000000000000000044444444444444444444444444444444444444440000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000006adb314c00000000000000000000000000000000000000000000000000000000000001200000000000000000000000000000000000000000000000000000000000000041111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000",
    "expiresAt": "2026-10-23T10:05:00.000Z",
    "from": "0x19e7e376e7c213b7e7e7e46cc70a5dd086daff2a",
    "preparationId": "preparation_escrow",
    "purpose": "createEscrow",
    "to": "0x3333333333333333333333333333333333333333",
    "value": "0"
  },
  "approvalRequired": false,
  "approval": {
    "allowance": "0",
    "required": false,
    "requiredAmount": "0",
    "spender": "0x3333333333333333333333333333333333333333",
    "tokenAddress": "0x4444444444444444444444444444444444444444"
  }
}
```

**SDK Code**

```python Success
import requests

url = "https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript Success
const url = 'https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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

```go Success
package main

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

func main() {

	url := "https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo"

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

	req.Header.Add("Authorization", "Bearer <token>")

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

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

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

}
```

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

url = URI("https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

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

HttpResponse<String> response = Unirest.get("https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp Success
using RestSharp;

var client = new RestClient("https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift Success
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://us-central1-sinbad-staging-env.cloudfunctions.net/b2b-v1/v1/trade-breakdowns/breakdown_demo")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()
```