### Get OrderBook - Go Example

Source: https://docs.btcturk.com/public-endpoints/orderbook

This Go program demonstrates how to make an HTTP GET request to the BTCTurk order book API. It sets the necessary headers and prints both the HTTP response status and the body content.

```Go
uri := "https://api.btcturk.com/api/v2/orderbook?pairSymbol=BTCUSDT"

request, _ := http.NewRequest("GET", uri, nil)

request.Header.Add("Content-Type", "application/json")

response, _ := http.DefaultClient.Do(request)

defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)

fmt.Println(response)
fmt.Println(string(body))
```

--------------------------------

### Get OrderBook - C# Example

Source: https://docs.btcturk.com/public-endpoints/orderbook

Example of how to fetch order book data using the BTCTurk API client library for .NET Core. It demonstrates initializing the client with API keys and fetching order book data for a given pair symbol.

```C#
var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();

var publicKey = configuration["publicKey"];
var privateKey = configuration["privateKey"];
var resourceUrl = configuration["resourceUrl"];

var apiClientV1 = new ApiClientV1(publicKey, privateKey, resourceUrl);
var orderbook = apiClientV1.GetOrderBook("BTCTRY");

if (orderbook.Result.Success)
{
    var bestBidPrice = orderbook.Result.Data.Bids[0][0];
    var bestBidAmount = orderbook.Result.Data.Bids[0][1];
    Console.WriteLine("Best bid price:" + bestBidPrice);
    Console.WriteLine("Best bid amount:" + bestBidAmount);
}
else
{
    Console.WriteLine(orderbook.Result.ToString());
}
```

--------------------------------

### Get Open Orders in C#

Source: https://docs.btcturk.com/private-endpoints/open-orders

This C# example shows how to fetch open orders using the BTCTurk API client library. It reads API credentials from appsettings.json and processes the results, printing ask and bid orders to the console.

```C#
using System;
using System.IO;
using Microsoft.Extensions.Configuration;
using BTCTurk.ApiClient.Api;

public class OpenOrdersExample
{
    public static void Main(string[] args)
    {
        // Load configuration from appsettings.json
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json")
            .Build();

        var publicKey = configuration["publicKey"];
        var privateKey = configuration["privateKey"];
        var resourceUrl = configuration["resourceUrl"];

        // Initialize the API client
        var apiClientV1 = new ApiClientV1(publicKey, privateKey, resourceUrl);

        // Fetch open orders
        var openOrders = apiClientV1.GetOpenOrders();

        // Process the results
        if (openOrders.Result != null && openOrders.Result.Success)
        {
            Console.WriteLine("Open Ask Orders:");
            foreach (var askOrder in openOrders.Result.Data.Asks)
            {
                Console.WriteLine(askOrder);
            }

            Console.WriteLine("\nOpen Bid Orders:");
            foreach (var bidOrder in openOrders.Result.Data.Bids)
            {
                Console.WriteLine(bidOrder);
            }
        }
        else
        {
            Console.WriteLine($"Error fetching open orders: {openOrders.Result?.Message}");
        }
    }
}
```

--------------------------------

### Get OrderBook - Node.js Example

Source: https://docs.btcturk.com/public-endpoints/orderbook

A Node.js example using the `fetch` API to retrieve order book data. It specifies the HTTP method and headers, then processes the JSON response, logging it to the console or any errors encountered.

```Node.js
const base = 'https://api.btcturk.com'
const method = '/api/v2/orderbook?pairSymbol=BTCUSDT'
const uri = base+method;

const options = {method: 'GET', headers: {'Content-type': 'application/json'};

fetch(uri, options)
    .then(res => res.json())
    .then(json => console.log(json))
    .catch(err => console.error('error:' + err));
```

--------------------------------

### Fetch BTCTurk Order Details

Source: https://docs.btcturk.com/private-endpoints/get-single-order

Client-side code examples demonstrating how to authenticate and fetch order details from the BTCTurk API. These snippets cover signature generation and making the GET request.

```php
<?php
$base = "https://api.btcturk.com";
$apiKey = "YOUR_API_PUBLIC_KEY";
$apiSecret = "YOUR_API_SECRET";
$method = "/api/v1/order/ORDERID_HERE";
$uri = $base.$method;

$nonce = time()*1000;
$message = $apiKey.$nonce;
$signatureBytes = hash_hmac("sha256", $message, base64_decode($apiSecret), true);
$signature = base64_encode($signatureBytes);
$headers = array(
    "X-PCK: ".$apiKey,
    "X-Stamp: ".$nonce,
    "X-Signature: ".$signature,
    "Cache-Control: no-cache",
    "Content-Type: application/json"
);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $uri);
curl_setopt($ch, CURLOPT_HTTP_VERSION, "CURL_HTTP_VERSION_1_2");
curl_setopt($ch, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
$result = curl_exec($ch);

if (curl_errno($ch)) {
    print_r(curl_error($ch));
}
$answer = json_decode($result);
print_r($answer);
?>
```

```python
import time, base64, hmac, hashlib, requests, json

base = "https://api.btcturk.com"
method = "/api/v1/order/ORDERID_HERE"
uri = base+method

apiKey = "YOUR_API_PUBLIC_KEY"
apiSecret = "YOUR_API_SECRET"
apiSecret = base64.b64decode(apiSecret)

stamp = str(int(time.time())*1000)
data = "{}{}".format(apiKey, stamp).encode("utf-8")
signature = hmac.new(apiSecret, data, hashlib.sha256).digest()
signature = base64.b64encode(signature)
headers = {"X-PCK": apiKey, "X-Stamp": stamp, "X-Signature": signature, "Content-Type" : "application/json"}

result = requests.get(url=uri, headers=headers)
result = result.json()
print(json.dumps(result, indent=2))
```

```go
package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"
)

func main() {
	publicKey := "PUBLIC_KEY_HERE"
	privateKey := "PRIVATE_KEY_HERE"

	base := "https://api.btcturk.com"
	method := "/api/v1/order/{orderId}"
	uri := base + method

	key, error := base64.StdEncoding.DecodeString(privateKey)

	if error != nil {
		fmt.Println("Error decoding private key:", error)
		return
	}

	nonce := fmt.Sprint(time.Now().UTC().UnixMilli())
	message := publicKey + nonce
	hmac := hmac.New(sha256.New, key)
	hmac.Write([]byte(message))
	signature := base64.StdEncoding.EncodeToString(hmac.Sum(nil))

	request, _ := http.NewRequest("GET", uri, nil)

	request.Header.Set("X-PCK", publicKey)
	request.Header.Set("X-Stamp", nonce)
	request.Header.Set("X-Signature", signature)
	request.Header.Set("Content-Type", "application/json")

	response, error := http.DefaultClient.Do(request)

	if error != nil {
		fmt.Println("Error making request:", error)
		return
	}

	defer response.Body.Close()
	body, error := ioutil.ReadAll(response.Body)

	if error != nil {
		fmt.Println("Error reading response body:", error)
		return
	}

	fmt.Println("Response Status:", response.Status)
	fmt.Println("Response Body:", string(body))
}
```

```nodejs
const API_KEY = "API_KEY_HERE"
const API_SECRET = "API_SECRET_HERE"

const base = 'https://api.btcturk.com'
const method = '/api/v1/order/{orderId}'
const uri = base+method;

const options = {method: 'GET', headers: authentication()};

fetch(uri, options)
    .then(res => res.json())
    .then(json => console.log(json))
    .catch(err => console.error('error:' + err));


function authentication() {
    const stamp = (new Date()).getTime()
    const data = Buffer.from(`${API_KEY}${stamp}`, 'utf8')
    const buffer = crypto.createHmac('sha256', Buffer.from(API_SECRET, 'base64'))
    buffer.update(data)
    const digest = buffer.digest()
    const signature = Buffer.from(digest.toString('base64'), 'utf8').toString('utf8')

    return {
        "Content-type": 'application/json',
        "X-PCK": API_KEY,
        "X-Stamp": stamp.toString(),
        "X-Signature": signature,
    }
}
```

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

public_key = 'PUBLIC_KEY_HERE'
private_key = 'PRIVATE_KEY_HERE'

uri = URI.parse("https://api.btcturk.com/api/v1/order/{orderId}")
timestamp = Time.now.to_i*1000
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri.request_uri)

data = public_key + timestamp.to_s
private_key = Base64.decode64(private_key).strip

hmac = OpenSSL::HMAC.digest('sha256', private_key, data)
signature = Base64.encode64(hmac).strip

request['X-PCK'] = public_key
request['X-Stamp'] = timestamp.to_s
request['X-Signature'] = signature
request['Content-Type'] = 'application/json'

response = http.request(request)
puts "Response Status: #{response.code}"
puts "Response Body: #{response.body}"
```

--------------------------------

### Get OrderBook - Ruby Example

Source: https://docs.btcturk.com/public-endpoints/orderbook

This Ruby script utilizes the `net/http` library to fetch order book data. It sets up an SSL-enabled HTTP connection, makes a GET request with JSON content type, and prints the response body.

```Ruby
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://api.btcturk.com/api/v2/orderbook?pairSymbol=BTCUSDT")

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

request = Net::HTTP::Get.new(url)
request["Content-type"] = 'application/json'

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

--------------------------------

### Get Open Orders in GoLang

Source: https://docs.btcturk.com/private-endpoints/open-orders

This GoLang example demonstrates fetching open orders from BTCTurk. It includes decoding the private key, generating a timestamp and HMAC-SHA256 signature, and making an HTTP GET request with the required headers.

```GoLang
package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"fmt"
	"io/ioutil"
	"net/http"
	"time"
)

func main() {
	publicKey := "PUBLIC_KEY_HERE" // Replace with your public API key
	privateKey := "PRIVATE_KEY_HERE" // Replace with your private API secret

	base := "https://api.btcturk.com"
	method := "/api/v1/openOrders" // Add pairSymbol query param if needed, e.g., "/api/v1/openOrders?pairSymbol=BTCTRY"
	uri := base + method

	// Decode the private key from Base64
	key, err := base64.StdEncoding.DecodeString(privateKey)
	if err != nil {
		fmt.Printf("Error decoding private key: %v\n", err)
		return
	}

	// Generate nonce (timestamp in milliseconds)
	nonce := fmt.Sprint(time.Now().UTC().UnixMilli())

	// Create message for signature
	message := publicKey + nonce

	// Generate signature using HMAC-SHA256
	hmacHash := hmac.New(sha256.New, key)
	hmacHash.Write([]byte(message))
	signature := base64.StdEncoding.EncodeToString(hmacHash.Sum(nil))

	// Create HTTP request
	request, err := http.NewRequest("GET", uri, nil)
	if err != nil {
		fmt.Printf("Error creating request: %v\n", err)
		return
	}

	// Set request headers
	request.Header.Set("X-PCK", publicKey)
	request.Header.Set("X-Stamp", nonce)
	request.Header.Set("X-Signature", signature)
	request.Header.Set("Content-Type", "application/json")

	// Execute the request
	response, err := http.DefaultClient.Do(request)
	if err != nil {
		fmt.Printf("Error executing request: %v\n", err)
		return
	}

	defer response.Body.Close()

	// Read response body
	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Printf("Error reading response body: %v\n", err)
		return
	}

	// Print response details
	fmt.Printf("Status Code: %d\n", response.StatusCode)
	fmt.Println("Response Body:")
	fmt.Println(string(body))
}

```

--------------------------------

### All Orders API Response Example

Source: https://docs.btcturk.com/private-endpoints/all-orders

Example of a successful response (status code 200) from the /api/v1/allOrders endpoint, showing the structure of order data including ID, price, amount, pair symbol, type, and status.

```JSON
{
  "success": true,
  "message": null,
  "code": 0,
  "data": [
    {
      "id": 9932534,
      "price": "20000.00",
      "amount": "0.001",
      "quantity": "0.001",
      "pairsymbol": "BTCTRY",
      "pairsymbolnormalized":"BTC_TRY",
      "type": "Buy",
      "method": "Limit",
      "orderClientId": "test",
      "time": 1543996112263,
      "updateTime": 1543996112263,
      "status": "Untouched"
    },
    {
      "id": 9932533,
      "price": "21000.00",
      "amount": "0.001",
      "quantity": "0.001",
      "pairsymbol": "BTCTRY",
      "pairsymbolnormalized":"BTC_TRY",
      "type": "Buy",
      "method": "Limit",
      "orderClientId": "test",
      "time": 1543994632920,
      "updateTime": 1543994632920,
      "status": "Untouched"
    },
    {
      "id": 9932523,
      "price": "2000.00",
      "amount": "0.01",
      "quantity": "0.01",
      "pairsymbol": "BTCTRY",
      "pairsymbolnormalized":"BTC_TRY",
      "type": "Buy",
      "method": "Limit",
      "orderClientId": "test",
      "time": 1543500891493,
      "updateTime": 1543501769613,
      "status": "Canceled"
    }
  ]
}
```

--------------------------------

### Fetch BTCTurk Exchange Info

Source: https://docs.btcturk.com/public-endpoints/exchange-info

This section provides examples of how to retrieve exchange information from the BTCTurk API. It demonstrates making a GET request to the `/api/v2/server/exchangeinfo` endpoint. The response typically includes details about supported trading pairs, minimum order amounts, and other relevant exchange data.

```PHP
<?php
$base = "https://api.btcturk.com";
$method = "/api/v2/server/exchangeinfo";
$uri = $base.$method;

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $uri);
curl_setopt($ch, CURLOPT_HTTP_VERSION, "CURL_HTTP_VERSION_1_2");
curl_setopt($ch, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$result = curl_exec($ch);

if (curl_errno($ch)) {
    print_r(curl_error($ch));
}
$answer = json_decode($result);
print_r($answer);
?>
```

```Python
import time, base64, hmac, hashlib, requests, json

base = "https://api.btcturk.com"
method = "/api/v2/server/exchangeinfo"
uri = base+method

result = requests.get(url=uri)
result = result.json()
print(json.dumps(result, indent=2))
```

```GoLang
uri := "https://api.btcturk.com/api/v2/server/exchangeinfo"

request, _ := http.NewRequest("GET", uri , nil)

request.Header.Add("Content-type", "application/json")

response, _ := http.DefaultClient.Do(request)

defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)

fmt.Println(response)
fmt.Println(string(body))
```

```Node.js
const base = 'https://api.btcturk.com'
const method = '/api/v2/server/exchangeinfo'
const uri = base+method;

const options = {method: 'GET', headers: {'Content-type': 'application/json'};

fetch(uri, options)
    .then(res => res.json())
    .then(json => console.log(json))
    .catch(err => console.error('error:' + err));
```

```Ruby
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://api.btcturk.com/api/v2/server/exchangeinfo")

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

request = Net::HTTP::Get.new(url)
request["Content-type"] = 'application/json'

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

--------------------------------

### Get Account Balances

Source: https://docs.btcturk.com/private-endpoints/account-balance

Examples demonstrating how to fetch account balances from the BTCTurk API. These snippets require API credentials (public and private keys) and implement signature generation using HMAC-SHA256 for secure authentication. The output typically includes a list of currency balances.

```C#
// You can download ApiClient .net core complete library from github https://github.com/BTCTrader/broker-api-csharp-v2

var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();

var publicKey = configuration["publicKey"];
var privateKey = configuration["privateKey"];
var resourceUrl = configuration["resourceUrl"];
var apiClientV1 = new ApiClientV1(publicKey, privateKey, resourceUrl);

 var balances = apiClientV1.GetBalances();

if (balances.Result != null && balances.Result.Success)
{
    foreach (var balance in balances.Result.Data)
    {
        Console.WriteLine(balance.ToString());
    }
}
```

```PHP
<?php
$base = "https://api.btcturk.com";
$apiKey = "YOUR_API_PUBLIC_KEY";
$apiSecret = "YOUR_API_SECRET";
$method = "/api/v1/users/balances";
$uri = $base.$method;

$nonce = time()*1000;
$message = $apiKey.$nonce;
$signatureBytes = hash_hmac("sha256", $message, base64_decode($apiSecret), true);
$signature = base64_encode($signatureBytes);
$headers = array(
    "X-PCK: ".$apiKey,
    "X-Stamp: ".$nonce,
    "X-Signature: ".$signature,
    "Cache-Control: no-cache",
    "Content-Type: application/json");

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $uri);
curl_setopt($ch, CURLOPT_HTTP_VERSION, "CURL_HTTP_VERSION_1_2");
curl_setopt($ch, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
$result = curl_exec($ch);

if (curl_errno($ch)) {
    print_r(curl_error($ch));
}
$answer = json_decode($result);
print_r($answer);
?>
```

```Python
import time, base64, hmac, hashlib, requests, json

base = "https://api.btcturk.com"
method = "/api/v1/users/balances"
uri = base+method

apiKey = "YOUR_API_PUBLIC_KEY"
apiSecret = "YOUR_API_SECRET"
apiSecret = base64.b64decode(apiSecret)

stamp = str(int(time.time())*1000)
data = "{}{}".format(apiKey, stamp).encode("utf-8")
signature = hmac.new(apiSecret, data, hashlib.sha256).digest()
signature = base64.b64encode(signature)
headers = {"X-PCK": apiKey, "X-Stamp": stamp, "X-Signature": signature, "Content-Type" : "application/json"}

result = requests.get(url=uri, headers=headers)
result = result.json()
print(json.dumps(result, indent=2))
```

```GoLang
publicKey := "PUBLIC_KEY_HERE"
privateKey := "PRIVATE_KEY_HERE"

base       = "https://api.btcturk.com"
method     = "/api/v1/users/balances"
uri        = base + method

key, error := base64.StdEncoding.DecodeString(privateKey)

if error != nil {
	return error
}

nonce := fmt.Sprint(time.Now().UTC().UnixMilli())
message := publicKey + nonce
hmac := hmac.New(sha256.New, key)
hmac.Write([]byte(message))
signature := base64.StdEncoding.EncodeToString(hmac.Sum(nil))

request, _ := http.NewRequest("GET", uri, nil)

request.Header.Set("X-PCK", publicKey)
request.Header.Set("X-Stamp", nonce)
request.Header.Set("X-Signature", signature)
request.Header.Set("Content-Type", "application/json")

response, _ := http.DefaultClient.Do(request)

defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)

fmt.Println(response)
fmt.Println(string(body))
```

```Node.js
const API_KEY = "API_KEY_HERE"
const API_SECRET = "API_SECRET_HERE"

const base = 'https://api.btcturk.com'
const method = '/api/v1/users/balances'
const uri = base+method;

const options = {method: 'GET', headers: authentication()};

fetch(uri, options)
    .then(res => res.json())
    .then(json => console.log(json))
    .catch(err => console.error('error:' + err));


function authentication() {
    const stamp = (new Date()).getTime()
    const data = Buffer.from(`${API_KEY}${stamp}`, 'utf8')
    const buffer = crypto.createHmac('sha256', Buffer.from(API_SECRET, 'base64'))
    buffer.update(data)
    const digest = buffer.digest()
    const signature = Buffer.from(digest.toString('base64'), 'utf8').toString('utf8')

    return {
        "Content-type": 'application/json',
        "X-PCK": API_KEY,
        "X-Stamp": stamp.toString(),
        "X-Signature": signature,
    }
}
```

```Ruby
public_key = 'PUBLIC_KEY_HERE'
private_key = 'PRIVATE_KEY_HERE'

uri = URI.parse("https://api.btcturk.com/api/v1/users/balances")
timestamp = Time.now.to_i*1000
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri.request_uri)

data = public_key + timestamp.to_s
private_key = Base64.decode64(private_key).strip
digest = OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), private_key, data)
sign = Base64.encode64(digest).strip

request['Content-type'] = 'application/json'
request['X-PCK'] = public_key
request['X-Stamp'] = timestamp.to_s
request['X-Signature'] = sign

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

--------------------------------

### BTCTurk API Request Setup

Source: https://docs.btcturk.com/private-endpoints/get-fiat-transactions

Demonstrates how to set authentication headers (X-PCK, X-Stamp, X-Signature) for a request to BTCTurk and then execute the request. It includes handling the response body.

```ruby
request = Net::HTTP::Get.new(uri)
request['X-PCK'] = public_key
request['X-Stamp'] = timestamp.to_s
request['X-Signature'] = sign

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

--------------------------------

### Order Book Subscription Request Example

Source: https://docs.btcturk.com/websocket-feed/models

Example JSON payload for subscribing to order book data, specifying the channel, event, and pair symbol.

```json
[151,{"type":151,"channel":"orderbook","event":"BTCTRY","join":true}]
```

--------------------------------

### Get Open Orders in Node.js

Source: https://docs.btcturk.com/private-endpoints/open-orders

This Node.js example uses the `fetch` API and Node.js `crypto` module to get open orders. It defines an `authentication` function to generate the required signature and headers for the API request.

```Node.js
const crypto = require('crypto');

const API_KEY = "API_KEY_HERE"; // Replace with your public API key
const API_SECRET = "API_SECRET_HERE"; // Replace with your private API secret

const base = 'https://api.btcturk.com';
const method = '/api/v1/openOrders?pairSymbol=BTCTRY'; // Or "BTCUSDT", etc.
const uri = base+method;

// Function to generate authentication headers
function authentication() {
    const stamp = (new Date()).getTime(); // Timestamp in milliseconds
    const data = Buffer.from(`${API_KEY}${stamp}`, 'utf8');

    // Create HMAC-SHA256 signature
    const buffer = crypto.createHmac('sha256', Buffer.from(API_SECRET, 'base64'))
    buffer.update(data);
    const digest = buffer.digest();
    const signature = Buffer.from(digest.toString('base64'), 'utf8').toString('utf8');

    return {
        "Content-type": 'application/json',
        "X-PCK": API_KEY,
        "X-Stamp": stamp.toString(),
        "X-Signature": signature,
    };
}

// Options for the fetch request
const options = {
    method: 'GET',
    headers: authentication()
};

// Make the fetch request
fetch(uri, options)
    .then(res => {
        if (!res.ok) {
            throw new Error(`HTTP error! status: ${res.status}`);
        }
        return res.json();
    })
    .then(json => console.log(JSON.stringify(json, null, 2)))
    .catch(err => console.error('error:', err));

```

--------------------------------

### Language Support for Code Examples

Source: https://docs.btcturk.com/recent-changes

Announces the addition of code examples for Golang and Node.js, expanding the available language support. The document now includes samples for C#, Python, PHP, GoLang, and Node.js.

```APIDOC
Supported Languages for Code Examples:

- C#
- Python
- PHP
- GoLang
- Node.js
```

--------------------------------

### Get Latest Trades via BTCTurk API

Source: https://docs.btcturk.com/public-endpoints/trades

Demonstrates how to retrieve the latest trade data for a specified trading pair using the BTCTurk API. It covers making GET requests to the /api/v2/trades endpoint and handling the JSON response.

```APIDOC
GET https://api.btcturk.com/api/v2/trades

Description:
  Gets a list of the latest trades for a product.

Query Parameters:
  - pairSymbol (string, required): The trading pair symbol (e.g., BTCUSDT, BTCTRY).
  - last (integer, optional): Indicates how many of the latest trades to retrieve. Maximum is 50.

Example Usage:
  - Get default 50 trades for BTCUSDT:
    https://api.btcturk.com/api/v2/trades?pairSymbol=BTCUSDT
  - Get 30 latest trades for BTCUSDT:
    https://api.btcturk.com/api/v2/trades?pairSymbol=BTCUSDT&last=30

Successful Response (200 OK):
  {
    "success": true,
    "message": null,
    "code": 0,
    "data": [
      {
        "pair": "BTCTRY",
        "pairNormalized": "BTC_TRY",
        "numerator": "BTC",
        "denominator": "TRY",
        "date": 1533650242300,
        "tid": "636692470417865271",
        "price": "33490",
        "amount": "0.00032747"
      }
      // ... more trade objects
    ]
  }

Error Conditions:
  - Invalid pairSymbol.
  - 'last' parameter exceeds the maximum limit of 50.
```

```C#
var configuration = new ConfigurationBuilder().AddJsonFile("appsettings.json").Build();

var publicKey = configuration["publicKey"];
var privateKey = configuration["privateKey"];
var resourceUrl = configuration["resourceUrl"];
var apiClientV1 = new ApiClientV1(publicKey, privateKey, resourceUrl);

var trades = apiClientV1.GetLastTrades("BTCTRY", 10);

if (trades.Result.Success)
{
    Console.WriteLine("Last 10 trades in the market");
    foreach (var trade in trades.Result.Data)
    {
        Console.WriteLine(trade.ToString());
    }
}
else
{
    Console.WriteLine(trades.Result.ToString());
}
```

```PHP
<?php
$base = "https://api.btcturk.com";
$method = "/api/v2/trades?pairSymbol=BTCTRY&last=50";
$uri = $base.$method;

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $uri);
curl_setopt($ch, CURLOPT_HTTP_VERSION, "CURL_HTTP_VERSION_1_2");
curl_setopt($ch, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$result = curl_exec($ch);

if (curl_errno($ch)) {
    print_r(curl_error($ch));
}
$answer = json_decode($result);
print_r($answer);
?>
```

```Python
import time, base64, hmac, hashlib, requests, json

base = "https://api.btcturk.com"
method = "/api/v2/trades?pairSymbol=BTCTRY&last=50"
uri = base+method

result = requests.get(url=uri)
result = result.json()
print(json.dumps(result, indent=2))
```

```GoLang
uri := "https://api.btcturk.com/api/v2/trades?pairSymbol=BTCUSDT"

request, _ := http.NewRequest("GET", uri, nil)

request.Header.Add("Content-Type", "application/json")

response, _ := http.DefaultClient.Do(request)

defer response.Body.Close()
body, _ := ioutil.ReadAll(response.Body)

fmt.Println(response)
fmt.Println(string(body))
```

```Node.js
const base = 'https://api.btcturk.com'
const method = '/api/v2/trades?pairSymbol=BTCUSDT'
const uri = base+method;

const options = {method: 'GET', headers: {'Content-type': 'application/json'};

fetch(uri, options)
    .then(res => res.json())
    .then(json => console.log(json))
    .catch(err => console.error('error:' + err));
```

```Ruby
require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://api.btcturk.com/api/v2/trades?pairSymbol=BTCUSDT")

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

request = Net::HTTP::Get.new(url)
request["Content-type"] = 'application/json'

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

--------------------------------

### C# WebSocket Example

Source: https://docs.btcturk.com/recent-changes

Highlights the addition of a C# code example specifically for WebSocket integration. This snippet is intended to help developers implement WebSocket functionality in their C# applications.

```APIDOC
C# WebSocket Example:

This section provides a code example for integrating with BTCTurk's WebSocket API using C#.
```

--------------------------------

### Cryptocurrency Configuration Example

Source: https://docs.btcturk.com/public-endpoints/exchange-info

This snippet illustrates the typical JSON structure used to define cryptocurrency configurations. It includes essential details such as minimum deposit/withdrawal amounts, address length requirements, and whether a tag is needed for transactions.

```json
[
    {
        "id": 48,
        "symbol": "AAVE",
        "minWithdrawal": 0.5000000000000000,
        "minDeposit": 0.1000000000000000,
        "precision": 4,
        "address": {
            "minLen": 40,
            "maxLen": 42
        },
        "currencyType": "CRYPTO",
        "tag": {
            "enable": false,
            "name": null,
            "minLen": null,
            "maxLen": null
        },
        "color": "#383d51",
        "name": "Aave",
        "isAddressRenewable": false,
        "getAutoAddressDisabled": true,
        "isPartialWithdrawalEnabled": true,
        "isNew": false
    },
    {
        "id": 18,
        "symbol": "ADA",
        "minWithdrawal": 20.0000000000000000,
        "minDeposit": 1.0000000000000000,
        "precision": 4,
        "address": {
            "minLen": 12,
            "maxLen": 105
        },
        "currencyType": "CRYPTO",
        "tag": {
            "enable": false,
            "name": null,
            "minLen": null,
            "maxLen": null
        },
        "color": "#2DBCBC",
        "name": "Cardano",
        "isAddressRenewable": false,
        "getAutoAddressDisabled": true,
        "isPartialWithdrawalEnabled": true,
        "isNew": false
    },
    {
        "id": 51,
        "symbol": "AMP",
        "minWithdrawal": 1000.0000000000000000,
        "minDeposit": 2.0000000000000000,
        "precision": 4,
        "address": {
            "minLen": 40,
            "maxLen": 42
        },
        "currencyType": "CRYPTO",
        "tag": {
            "enable": false,
            "name": null,
            "minLen": null,
            "maxLen": null
        },
        "color": "#d9327c",
        "name": "Amp",
        "isAddressRenewable": false,
        "getAutoAddressDisabled": true,
        "isPartialWithdrawalEnabled": true,
        "isNew": false
    },
    {
        "id": 23,
        "symbol": "ANKR",
        "minWithdrawal": 500.0000000000000000,
        "minDeposit": 2.0000000000000000,
        "precision": 4,
        "address": {
            "minLen": 40,
            "maxLen": 42
        },
        "currencyType": "CRYPTO",
        "tag": {
            "enable": false,
            "name": null,
            "minLen": null,
            "maxLen": null
        },
        "color": "#2F77D9",
        "name": "Ankr",
        "isAddressRenewable": false,
        "getAutoAddressDisabled": true,
        "isPartialWithdrawalEnabled": true,
        "isNew": false
    },
    {
        "id": 14,
        "symbol": "ATOM",
        "minWithdrawal": 0.5000000000000000,
        "minDeposit": 0.5000000000000000,
        "precision": 6,
        "address": {
            "minLen": 45,
            "maxLen": 45
        },
        "currencyType": "CRYPTO",
        "tag": {
            "enable": true,
            "name": "Memo",
            "minLen": 0,
            "maxLen": 256
        },
        "color": "#545E96",
        "name": "Cosmos",
        "isAddressRenewable": false,
        "getAutoAddressDisabled": true,
        "isPartialWithdrawalEnabled": true,
        "isNew": false
    },
    {
        "id": 52,
        "symbol": "AUDIO",
        "minWithdrawal": 50.0000000000000000,
        "minDeposit": 2.0000000000000000,
        "precision": 4,
        "address": {
            "minLen": 40,
            "maxLen": 42
        },
        "currencyType": "CRYPTO",
        "tag": {
            "enable": false,
            "name": null,
            "minLen": null,
            "maxLen": null
        },
        "color": "#d48222",
        "name": "Bitcoin",
        "isAddressRenewable": true,
        "getAutoAddressDisabled": true,
        "isPartialWithdrawalEnabled": true,
        "isNew": false
    }
]
```