# GetOrderDetails

POST https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails
Content-Type: application/json

Retrieve detailed information about a specific order.

Reference: https://docs.brij.fi/api/brij-partner-api/brij-core-v-1-partner-service-get-order-details

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: partner-api
  version: 1.0.0
paths:
  /brij.core.v1.partner.Service/GetOrderDetails:
    post:
      operationId: brij-core-v-1-partner-service-get-order-details
      summary: GetOrderDetails
      description: Retrieve detailed information about a specific order.
      tags:
        - ''
      parameters:
        - name: X-API-Key
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/brij.core.v1.partner.GetOrderDetailsResponse
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/brij.core.v1.partner.GetOrderDetailsRequest'
servers:
  - url: https://api-demo.brij.fi
  - url: https://api.brij.fi
components:
  schemas:
    brij.core.v1.partner.GetOrderDetailsRequest:
      type: object
      properties:
        orderId:
          type: string
      title: brij.core.v1.partner.GetOrderDetailsRequest
    brij.core.v1.Order.Status:
      type: string
      enum:
        - AWAITING_FUNDS
        - FUNDS_RECEIVED
        - PAYMENT_SUBMITTED
        - PAYMENT_PROCESSED
        - REFUNDING
        - REFUNDED
        - CANCELED
        - ERROR
        - IN_REVIEW
      title: brij.core.v1.Order.Status
    brij.data.v1.TransactionType:
      type: string
      enum:
        - ONRAMP
        - OFFRAMP
      description: TransactionType represents the direction of a crypto transaction
      title: brij.data.v1.TransactionType
    brij.data.v1.DepositInstructions:
      type: object
      properties:
        paymentMethod:
          type: string
        network:
          type: string
        amount:
          type: string
        currency:
          type: string
        fromAddress:
          type: string
        toAddress:
          type: string
        depositMessage:
          type: string
        bankName:
          type: string
        bankAddress:
          type: string
        bankRoutingNumber:
          type: string
        bankAccountNumber:
          type: string
        bankBeneficiaryName:
          type: string
        bankBeneficiaryAddress:
          type: string
        iban:
          type: string
        bic:
          type: string
        clabe:
          type: string
        accountHolderName:
          type: string
        blockchainMemo:
          type: string
      title: brij.data.v1.DepositInstructions
    brij.data.v1.ReturnDetails:
      type: object
      properties:
        reason:
          type: string
        refundReferenceId:
          type: string
      title: brij.data.v1.ReturnDetails
    google.protobuf.Timestamp:
      type: string
      format: date-time
      description: >-
        A Timestamp represents a point in time independent of any time zone or
        local
         calendar, encoded as a count of seconds and fractions of seconds at
         nanosecond resolution. The count is relative to an epoch at UTC midnight on
         January 1, 1970, in the proleptic Gregorian calendar which extends the
         Gregorian calendar backwards to year one.

         All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
         second table is needed for interpretation, using a [24-hour linear
         smear](https://developers.google.com/time/smear).

         The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
         restricting to that range, we ensure that we can convert to and from [RFC
         3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

         # Examples

         Example 1: Compute Timestamp from POSIX `time()`.

             Timestamp timestamp;
             timestamp.set_seconds(time(NULL));
             timestamp.set_nanos(0);

         Example 2: Compute Timestamp from POSIX `gettimeofday()`.

             struct timeval tv;
             gettimeofday(&tv, NULL);

             Timestamp timestamp;
             timestamp.set_seconds(tv.tv_sec);
             timestamp.set_nanos(tv.tv_usec * 1000);

         Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

             FILETIME ft;
             GetSystemTimeAsFileTime(&ft);
             UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

             // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
             // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
             Timestamp timestamp;
             timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
             timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

         Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

             long millis = System.currentTimeMillis();

             Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
                 .setNanos((int) ((millis % 1000) * 1000000)).build();

         Example 5: Compute Timestamp from Java `Instant.now()`.

             Instant now = Instant.now();

             Timestamp timestamp =
                 Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                     .setNanos(now.getNano()).build();

         Example 6: Compute Timestamp from current time in Python.

             timestamp = Timestamp()
             timestamp.GetCurrentTime()

         # JSON Mapping

         In JSON format, the Timestamp type is encoded as a string in the
         [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
         format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
         where {year} is always expressed using four digits while {month}, {day},
         {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
         seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
         are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
         is required. A proto3 JSON serializer should always use UTC (as indicated by
         "Z") when printing the Timestamp type and a proto3 JSON parser should be
         able to accept both UTC and other timezones (as indicated by an offset).

         For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
         01:30 UTC on January 15, 2017.

         In JavaScript, one can convert a Date object to this format using the
         standard
         [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
         method. In Python, a standard `datetime.datetime` object can be converted
         to this format using
         [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
         the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
         the Joda Time's [`ISODateTimeFormat.dateTime()`](
         http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
         ) to obtain a formatter capable of generating timestamps in this format.
      title: google.protobuf.Timestamp
    brij.core.v1.Order:
      type: object
      properties:
        id:
          type: string
        customerId:
          type: string
          description: Only populated for partner APIs
        externalId:
          type: string
          description: Only populated for partner APIs
        partnerId:
          type: string
        status:
          $ref: '#/components/schemas/brij.core.v1.Order.Status'
        sourceCurrency:
          type: string
          description: Source currency code (e.g., "USD", "BTC")
        sourceAmount:
          type: string
          description: Decimal amount as string (e.g., "100.00", "0.5")
        destinationCurrency:
          type: string
          description: Target currency code (e.g., "BTC", "USD")
        destinationAmount:
          type: string
          description: Decimal amount as string (e.g., "0.5", "100.00")
        transactionType:
          $ref: '#/components/schemas/brij.data.v1.TransactionType'
        network:
          type: string
          description: Blockchain network (calculated, e.g., "ETHEREUM", "SOLANA")
        depositInstructions:
          $ref: '#/components/schemas/brij.data.v1.DepositInstructions'
        customerPaymentDetailsDataId:
          type: string
          description: Customer's payment details (e.g., bank account)
        customerWalletDataId:
          type: string
          description: Customer's crypto wallet address
        sourceTransactionId:
          type: string
          description: Transaction ID for source transaction
        destinationTransactionId:
          type: string
          description: Transaction ID for destination transaction
        paymentMethod:
          type: string
          description: Payment method code (e.g., "EUR_SEPA", "USA_WIRE")
        reason:
          type: string
          description: Reason for error or cancellation - only populated for partner APIs
        returnDetails:
          $ref: '#/components/schemas/brij.data.v1.ReturnDetails'
        createdAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
        updatedAt:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
      description: |-
        Order message - used for both partner and customer APIs
         For customer APIs, sensitive fields (customer_id, reason) are not populated
      title: brij.core.v1.Order
    brij.core.v1.partner.GetOrderDetailsResponse:
      type: object
      properties:
        order:
          $ref: '#/components/schemas/brij.core.v1.Order'
      title: brij.core.v1.partner.GetOrderDetailsResponse
  securitySchemes:
    PartnerApiKey:
      type: apiKey
      in: header
      name: X-API-Key

```

## SDK Code Examples

```python Success
import requests

url = "https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails"

payload = { "orderId": "order_123" }
headers = {
    "X-API-Key": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

```javascript Success
const url = 'https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails';
const options = {
  method: 'POST',
  headers: {'X-API-Key': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"orderId":"order_123"}'
};

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"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails"

	payload := strings.NewReader("{\n  \"orderId\": \"order_123\"\n}")

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

	req.Header.Add("X-API-Key", "<apiKey>")
	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 Success
require 'uri'
require 'net/http'

url = URI("https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails")

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

request = Net::HTTP::Post.new(url)
request["X-API-Key"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"orderId\": \"order_123\"\n}"

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.post("https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails")
  .header("X-API-Key", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"orderId\": \"order_123\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails', [
  'body' => '{
  "orderId": "order_123"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-API-Key' => '<apiKey>',
  ],
]);

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

```csharp Success
using RestSharp;

var client = new RestClient("https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails");
var request = new RestRequest(Method.POST);
request.AddHeader("X-API-Key", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"orderId\": \"order_123\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift Success
import Foundation

let headers = [
  "X-API-Key": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = ["orderId": "order_123"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-demo.brij.fi/brij.core.v1.partner.Service/GetOrderDetails")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
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()
```