import json
import requests

payload={}

url = "https://coinswitch.co/trade/api/v2/time"

headers = {
  'Content-Type': 'application/json',
}


response = requests.request("GET", url, headers=headers, json=payload)

public String getServerTime() throws Exception {
  HashMap<String, String> parameters = new HashMap<>();
  HashMap<String, Object> payload = new HashMap<>();

  return this.makeRequest("GET", "/trade/api/v2/time", payload, parameters);
}

{
    "serverTime": 1719905777483
}

from cryptography.hazmat.primitives.asymmetric import ed25519
from urllib.parse import urlparse, urlencode
import urllib
import json
import time 

 # example method  ['GET', 'POST', 'DELETE']

 # params represent the query params we need to pass during GET call

def get_signature(method, endpoint, params, epoch_time):
  unquote_endpoint = endpoint
  if method == "GET" and len(params) != 0:
      endpoint += ('&', '?')[urlparse(endpoint).query == ''] + urlencode(params)
      unquote_endpoint = urllib.parse.unquote_plus(endpoint)

  signature_msg = method + unquote_endpoint + epoch_time

  request_string = bytes(signature_msg, 'utf-8')
  secret_key_bytes = bytes.fromhex(secret_key)
  secret_key = ed25519.Ed25519PrivateKey.from_private_bytes(secret_key_bytes)
  signature_bytes = secret_key.sign(request_string)
  signature = signature_bytes.hex()
  return signature

  public class Main {
    public static void main(String[] args) throws Exception {
        Main main = new Main();
        HashMap<String, String> parameters = new HashMap<>();
        HashMap<String, Object> payload = new HashMap<>();

        String epochTime = System.currentTimeMillis()+"";
        String Response = main.generateSignature("GET", "/trade/api/v2/orders", parameters, epochTime);
        System.out.println(Response);
    }

  private String paramsToString(Map<String, String> params) throws Exception {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (sb.length() > 0) {
                sb.append("&");
            }
            sb.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            sb.append("=");
            sb.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }
        return sb.toString();
    }

    private String signatureMessage(String method, String endpoint, String , String epochTime) throws Exception {
        return method + endpoint + epochTime;
    }

    public String getSignatureOfRequest(String secretKey, String requestString) {
        byte[] requestBytes = requestString.getBytes(StandardCharsets.UTF_8);
        byte[] secretKeyBytes = Hex.decode(secretKey);

        // Generate private key
        Ed25519PrivateKeyParameters privateKey = new Ed25519PrivateKeyParameters(secretKeyBytes, 0);

        // Sign the request
        Ed25519Signer signer = new Ed25519Signer();
        signer.init(true, privateKey);
        signer.update(requestBytes, 0, requestBytes.length);
        byte[] signatureBytes = signer.generateSignature();

        String signatureHex = Hex.toHexString(signatureBytes);
        return signatureHex;
    }

  public String generateSignature(String method, String endpoint, HashMap<String, String> params, String epochTime) throws Exception{
    String decodedEndpoint = endpoint;
    String secretKey = ""; // provided by coinswitch

    if (method.equals("GET") && !params.isEmpty()) {
        String query = new URI(endpoint).getQuery();
        endpoint += (query == null || query.isEmpty()) ? "?" : "&";
        endpoint += URLEncoder.encode(paramsToString(params), "UTF-8");
        decodedEndpoint = URLDecoder.decode(endpoint, "UTF-8");
    }

    String signatureMsg = signatureMessage(method, decodedEndpoint, epochTime);
    String signature = getSignatureOfRequest(secretKey, signatureMsg);
    return signature;
  }
}

from cryptography.hazmat.primitives.asymmetric import ed25519
from urllib.parse import urlparse, urlencode
import urllib
import json
import requests
import time

params = {
    "count": 20,
    "from_time": 1600261657954,
    "to_time": 1687261657954,
    "side": "sell",
    "symbols": "btc/inr,eth/inr",
    "exchanges": "coinswitchx,wazirx",
    "type": "limit",
    "open": True
}

endpoint = "/trade/api/v2/orders"
method = "GET"
payload = {}

secret_key = < secret_key >  # provided by coinswitch
api_key = < api_key> # provided by coinswitch
epoch_time = str(int(time.time() * 1000))

unquote_endpoint = endpoint
if method == "GET" and len(params) != 0:
    endpoint += ('&', '?')[urlparse(endpoint).query == ''] + urlencode(params)
    unquote_endpoint = urllib.parse.unquote_plus(endpoint)

signature_msg = method + unquote_endpoint + epoch_time

request_string = bytes(signature_msg, 'utf-8')
secret_key_bytes = bytes.fromhex(secret_key)
secret_key = ed25519.Ed25519PrivateKey.from_private_bytes(secret_key_bytes)
signature_bytes = secret_key.sign(request_string)
signature = signature_bytes.hex()

url = "https://coinswitch.co" + endpoint

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': signature,
  'X-AUTH-APIKEY': api_key,
  'X-AUTH-EPOCH': epoch_time
}

response = requests.request("GET", url, headers=headers, json=payload)

package com.example;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
import org.bouncycastle.crypto.signers.Ed25519Signer;
import org.bouncycastle.util.encoders.Hex;

import java.net.URI;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.math.BigDecimal;
import java.text.DecimalFormat;

public class Main {
    public static void main(String[] args) throws Exception {
        Main main = new Main();
        String Response = main.getOpenOrders();
        System.out.println(Response);
    }
    public String getOpenOrders() throws Exception {
        HashMap<String, String> parameters = new HashMap<>();
        HashMap<String, Object> payload = new HashMap<>();

        String path = "?&count=" + URLEncoder.encode("20", "UTF-8")
                + "&from_time=" + URLEncoder.encode("1600261657954", "UTF-8")+
                "&to_time=" + URLEncoder.encode("1687261657954", "UTF-8")+
                "&side=" + URLEncoder.encode("sell", "UTF-8")+
                "&type=" + URLEncoder.encode("limit", "UTF-8")+
                "&exchanges=" + URLEncoder.encode("coinswitchx,wazirx", "UTF-8")+
                "&symbols=" + URLEncoder.encode("btc/inr,eth/inr", "UTF-8")
                ;
        path = path.replaceAll("%2C", ",");
        path = path.replaceAll("%2F", "/");

        return this.makeRequest("GET","/trade/api/v2/orders" + path, payload, parameters);
    }

    public String makeRequest(String method, String endpoint, HashMap<String, Object> payload, HashMap<String, String> params) throws Exception {
        String secretKey = "" ; // provided by coinswitch

        String apiKey =  "";  // provided by coinswitch
        String epochTime = System.currentTimeMillis()+"";
        String decodedEndpoint = endpoint;
        if (method.equals("GET") && !params.isEmpty()) {
            String query = new URI(endpoint).getQuery();
            endpoint += (query == null || query.isEmpty()) ? "?" : "&";
            endpoint += URLEncoder.encode(paramsToString(params), "UTF-8");
            decodedEndpoint = URLDecoder.decode(endpoint, "UTF-8");
        }

        String signatureMsg = signatureMessage(method, decodedEndpoint, epochTime);
        String signature = getSignatureOfRequest(secretKey, signatureMsg);

        Map<String, String> headers = new HashMap<>();
        String url = "https://coinswitch.co" + endpoint;

        headers.put("X-AUTH-SIGNATURE", signature);
        headers.put("X-AUTH-APIKEY", apiKey);
        headers.put("X-AUTH-EPOCH", epochTime);
        if (method.equals("GET")){
            HttpResponse<String> response = callGetApi(url, headers, payload);
            return response.body().toString();
        }
        if (method.equals("POST") || method.equals("PUT") || method.equals("DELETE")){
            ObjectMapper objectMapper = new ObjectMapper();
            String json = objectMapper.writeValueAsString(payload);
            URL apiUrl = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) apiUrl.openConnection();

            // Set the request method to POST
            connection.setRequestMethod(method);
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("X-AUTH-SIGNATURE", signature);
            connection.setRequestProperty("X-AUTH-APIKEY", apiKey);
            // Enable output and set the request body
            connection.setDoOutput(true);
            connection.getOutputStream().write(json.getBytes());

            // Get the response code
            int responseCode = connection.getResponseCode();

            // Read the response
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            // Close the connection
            connection.disconnect();
            return  response.toString();
        };
        return "SUCCESS";
    }

    private String paramsToString(Map<String, String> params) throws Exception {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (sb.length() > 0) {
                sb.append("&");
            }
            sb.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            sb.append("=");
            sb.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }
        return sb.toString();
    }

    private String signatureMessage(String method, String endpoint, HashMap<String, Object> payload) throws Exception {
        TreeMap<String, Object> treeMap = new TreeMap<>(payload);
        String sortedPayloadJson = new ObjectMapper().writeValueAsString(treeMap);
        return method + endpoint + sortedPayloadJson;
    }

    public String getSignatureOfRequest(String secretKey, String requestString) {
        byte[] requestBytes = requestString.getBytes(StandardCharsets.UTF_8);
        byte[] secretKeyBytes = Hex.decode(secretKey);

        // Generate private key
        Ed25519PrivateKeyParameters privateKey = new Ed25519PrivateKeyParameters(secretKeyBytes, 0);

        // Sign the request
        Ed25519Signer signer = new Ed25519Signer();
        signer.init(true, privateKey);
        signer.update(requestBytes, 0, requestBytes.length);
        byte[] signatureBytes = signer.generateSignature();

        String signatureHex = Hex.toHexString(signatureBytes);
        return signatureHex;
    }
    private HttpResponse<String> callGetApi(String url, Map<String, String> headers, HashMap<String, Object> payload) throws Exception {
        HttpClient client = HttpClient.newBuilder().build();

        HttpRequest.Builder requestBuilder;

        requestBuilder = HttpRequest.newBuilder()
                .GET()
                .uri(new URI(url));


        for (Map.Entry<String, String> entry : headers.entrySet()) {
            requestBuilder.header(entry.getKey(), entry.getValue());
        }

        HttpRequest request = requestBuilder.build();

        return client.send(request, HttpResponse.BodyHandlers.ofString());
    }
}

from cryptography.hazmat.primitives.asymmetric import ed25519
from urllib.parse import urlparse, urlencode
import urllib
import json
import requests

payload = {
    "order_id": "698ed406-8ef5-4664-9779-f7978702a447"
}

endpoint = "/trade/api/v2/order"
method = "DELETE"
params = {}

secret_key = < secret_key >  # provided by coinswitch
api_key = < api_key> # provided by coinswitch

signature_msg = method + endpoint + json.dumps(payload, separators=(',', ':'), sort_keys=True)

request_string = bytes(signature_msg, 'utf-8')
secret_key_bytes = bytes.fromhex(secret_key)
secret_key = ed25519.Ed25519PrivateKey.from_private_bytes(secret_key_bytes)
signature_bytes = secret_key.sign(request_string)
signature = signature_bytes.hex()

url = "https://coinswitch.co" + endpoint

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': signature,
  'X-AUTH-APIKEY': api_key
}

response = requests.request("DELETE", url, headers=headers, json=payload)

package com.example;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
import org.bouncycastle.crypto.signers.Ed25519Signer;
import org.bouncycastle.util.encoders.Hex;

import java.net.URI;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.math.BigDecimal;
import java.text.DecimalFormat;

public class Main {
    public static void main(String[] args) throws Exception {
        Main main = new Main();
        String Response = main.cancelOrder();
        System.out.println(Response);
    }

   public String cancelOrder() throws  Exception{
       HashMap<String, String> parameters = new HashMap<>();
       HashMap<String, Object> payload = new HashMap<>();
       payload.put("order_id", "698ed406-8ef5-4664-9779-f7978702a447");
       return this.makeRequest("DELETE", "/trade/api/v2/order", payload, parameters);
   }

    public String makeRequest(String method, String endpoint, HashMap<String, Object> payload, HashMap<String, String> params) throws Exception {
        String secretKey = "" ; // provided by coinswitch
        String apiKey =  "";  // provided by coinswitch

        String decodedEndpoint = endpoint;
        if (method.equals("GET") && !params.isEmpty()) {
            String query = new URI(endpoint).getQuery();
            endpoint += (query == null || query.isEmpty()) ? "?" : "&";
            endpoint += URLEncoder.encode(paramsToString(params), "UTF-8");
            decodedEndpoint = URLDecoder.decode(endpoint, "UTF-8");
        }

        String signatureMsg = signatureMessage(method, decodedEndpoint, payload);
        String signature = getSignatureOfRequest(secretKey, signatureMsg);

        Map<String, String> headers = new HashMap<>();
        String url = "https://coinswitch.co" + endpoint;

        headers.put("X-AUTH-SIGNATURE", signature);
        headers.put("X-AUTH-APIKEY", apiKey);
        if (method.equals("GET")){
            HttpResponse<String> response = callGetApi(url, headers, payload);
            return response.body().toString();
        }
        if (method.equals("POST") || method.equals("PUT") || method.equals("DELETE")){
            ObjectMapper objectMapper = new ObjectMapper();
            String json = objectMapper.writeValueAsString(payload);
            URL apiUrl = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) apiUrl.openConnection();

            // Set the request method to POST
            connection.setRequestMethod(method);
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("X-AUTH-SIGNATURE", signature);
            connection.setRequestProperty("X-AUTH-APIKEY", apiKey);
            // Enable output and set the request body
            connection.setDoOutput(true);
            connection.getOutputStream().write(json.getBytes());

            // Get the response code
            int responseCode = connection.getResponseCode();

            // Read the response
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            // Close the connection
            connection.disconnect();
            return  response.toString();
        };
        return "SUCCESS";
    }

    private String paramsToString(Map<String, String> params) throws Exception {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (sb.length() > 0) {
                sb.append("&");
            }
            sb.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            sb.append("=");
            sb.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }
        return sb.toString();
    }

    private String signatureMessage(String method, String endpoint, HashMap<String, Object> payload) throws Exception {
        TreeMap<String, Object> treeMap = new TreeMap<>(payload);
        String sortedPayloadJson = new ObjectMapper().writeValueAsString(treeMap);
        return method + endpoint + sortedPayloadJson;
    }

    public String getSignatureOfRequest(String secretKey, String requestString) {
        byte[] requestBytes = requestString.getBytes(StandardCharsets.UTF_8);
        byte[] secretKeyBytes = Hex.decode(secretKey);

        // Generate private key
        Ed25519PrivateKeyParameters privateKey = new Ed25519PrivateKeyParameters(secretKeyBytes, 0);

        // Sign the request
        Ed25519Signer signer = new Ed25519Signer();
        signer.init(true, privateKey);
        signer.update(requestBytes, 0, requestBytes.length);
        byte[] signatureBytes = signer.generateSignature();

        String signatureHex = Hex.toHexString(signatureBytes);
        return signatureHex;
    }
    private HttpResponse<String> callGetApi(String url, Map<String, String> headers, HashMap<String, Object> payload) throws Exception {
        HttpClient client = HttpClient.newBuilder().build();

        HttpRequest.Builder requestBuilder;

        requestBuilder = HttpRequest.newBuilder()
                .GET()
                .uri(new URI(url));


        for (Map.Entry<String, String> entry : headers.entrySet()) {
            requestBuilder.header(entry.getKey(), entry.getValue());
        }

        HttpRequest request = requestBuilder.build();

        return client.send(request, HttpResponse.BodyHandlers.ofString());
    }
}

from cryptography.hazmat.primitives.asymmetric import ed25519
from urllib.parse import urlparse, urlencode
import urllib
import json
import requests

params = {}

endpoint = "/trade/api/v2/validate/keys"
method = "GET"
payload = {}

secret_key = < secret_key >  # provided by coinswitch
api_key = < api_key> # provided by coinswitch

unquote_endpoint = endpoint
if method == "GET" and len(params) != 0:
    endpoint += ('&', '?')[urlparse(endpoint).query == ''] + urlencode(params)
    unquote_endpoint = urllib.parse.unquote_plus(endpoint)

signature_msg = method + unquote_endpoint + json.dumps(payload, separators=(',', ':'), sort_keys=True)

request_string = bytes(signature_msg, 'utf-8')
secret_key_bytes = bytes.fromhex(secret_key)
secret_key = ed25519.Ed25519PrivateKey.from_private_bytes(secret_key_bytes)
signature_bytes = secret_key.sign(request_string)
signature = signature_bytes.hex()

url = "https://coinswitch.co" + endpoint

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': signature,
  'X-AUTH-APIKEY': api_key
}

response = requests.request("GET", url, headers=headers, json=payload)

package com.example;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters;
import org.bouncycastle.crypto.signers.Ed25519Signer;
import org.bouncycastle.util.encoders.Hex;

import java.net.URI;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.math.BigDecimal;
import java.text.DecimalFormat;


public class Main {
    public static void main(String[] args) throws Exception {
        Main main = new Main();
        String Response = main.ValidateKeys();
        System.out.println(Response);
    }

    public String ValidateKeys() throws Exception {
        HashMap<String, String> parameters = new HashMap<>();
        HashMap<String, Object> payload = new HashMap<>();

        return this.makeRequest("GET", "/trade/api/v2/validate/keys", payload, parameters);
    }


    public String makeRequest(String method, String endpoint, HashMap<String, Object> payload, HashMap<String, String> params) throws Exception {
        String secretKey = "" ; // provided by coinswitch
        String apiKey =  "";  // provided by coinswitch


        String decodedEndpoint = endpoint;
        if (method.equals("GET") && !params.isEmpty()) {
            String query = new URI(endpoint).getQuery();
            endpoint += (query == null || query.isEmpty()) ? "?" : "&";
            endpoint += URLEncoder.encode(paramsToString(params), "UTF-8");
            decodedEndpoint = URLDecoder.decode(endpoint, "UTF-8");
        }

        String signatureMsg = signatureMessage(method, decodedEndpoint, payload);
        String signature = getSignatureOfRequest(secretKey, signatureMsg);

        Map<String, String> headers = new HashMap<>();
        String url = "https://coinswitch.co" + endpoint;

        headers.put("X-AUTH-SIGNATURE", signature);
        headers.put("X-AUTH-APIKEY", apiKey);
        if (method.equals("GET")){
            HttpResponse<String> response = callGetApi(url, headers, payload);
            return response.body().toString();
        }
        if (method.equals("POST") || method.equals("PUT") || method.equals("DELETE")){
            ObjectMapper objectMapper = new ObjectMapper();
            String json = objectMapper.writeValueAsString(payload);
            URL apiUrl = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) apiUrl.openConnection();

            // Set the request method to POST
            connection.setRequestMethod(method);
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("X-AUTH-SIGNATURE", signature);
            connection.setRequestProperty("X-AUTH-APIKEY", apiKey);
            // Enable output and set the request body
            connection.setDoOutput(true);
            connection.getOutputStream().write(json.getBytes());

            // Get the response code
            int responseCode = connection.getResponseCode();

            // Read the response
            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            // Close the connection
            connection.disconnect();
            return  response.toString();
        };
        return "SUCCESS";
    }

    private String paramsToString(Map<String, String> params) throws Exception {
        StringBuilder sb = new StringBuilder();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (sb.length() > 0) {
                sb.append("&");
            }
            sb.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            sb.append("=");
            sb.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }
        return sb.toString();
    }

    private String signatureMessage(String method, String endpoint, HashMap<String, Object> payload) throws Exception {
        TreeMap<String, Object> treeMap = new TreeMap<>(payload);
        String sortedPayloadJson = new ObjectMapper().writeValueAsString(treeMap);
        return method + endpoint + sortedPayloadJson;
    }

    public String getSignatureOfRequest(String secretKey, String requestString) {
        byte[] requestBytes = requestString.getBytes(StandardCharsets.UTF_8);
        byte[] secretKeyBytes = Hex.decode(secretKey);

        // Generate private key
        Ed25519PrivateKeyParameters privateKey = new Ed25519PrivateKeyParameters(secretKeyBytes, 0);

        // Sign the request
        Ed25519Signer signer = new Ed25519Signer();
        signer.init(true, privateKey);
        signer.update(requestBytes, 0, requestBytes.length);
        byte[] signatureBytes = signer.generateSignature();

        String signatureHex = Hex.toHexString(signatureBytes);
        return signatureHex;
    }
    private HttpResponse<String> callGetApi(String url, Map<String, String> headers, HashMap<String, Object> payload) throws Exception {
        HttpClient client = HttpClient.newBuilder().build();

        HttpRequest.Builder requestBuilder;

        requestBuilder = HttpRequest.newBuilder()
                .GET()
                .uri(new URI(url));


        for (Map.Entry<String, String> entry : headers.entrySet()) {
            requestBuilder.header(entry.getKey(), entry.getValue());
        }

        HttpRequest request = requestBuilder.build();

        return client.send(request, HttpResponse.BodyHandlers.ofString());
    }
}

RESPONSE 200
{
  "message":"Valid Access"
}

RESPONSE 401
{
  "message":"Invalid Access"
}

import requests
import json

url = "https://coinswitch.co/trade/api/v2/ping"
payload = {}

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("GET", url, headers=headers, json=payload)

  public String ping() throws Exception {
    HashMap<String, String> parameters = new HashMap<>();
    HashMap<String, Object> payload = new HashMap<>();
    return this.makeRequest("GET", "/trade/api/v2/ping", payload, parameters);
 }

Response

{
  "message":"OK"
}

import requests
import json
from urllib.parse import urlparse, urlencode

params = {
    "exchange": "wazirx",
}
payload = {}

endpoint = "/trade/api/v2/coins"

endpoint += ('&', '?')[urlparse(endpoint).query == ''] + urlencode(params)

url = "https://coinswitch.co" + endpoint

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("GET", url, headers=headers, json=payload)

public String getCoins() throws Exception {
    HashMap<String, String> parameters = new HashMap<>();
    HashMap<String, Object> payload = new HashMap<>();

    String path = "?&exchange=" + URLEncoder.encode("wazirx", "UTF-8");
    path = path.replaceAll("%2C", ",");
    path = path.replaceAll("%2F", "/");

    return this.makeRequest("GET","/trade/api/v2/coins" + path, payload, parameters);
    }

Response: 200
{
    "data": {
        "wazirx": [
            "BAT/INR",
            "BNB/INR",
            "CHR/INR",
            "CRV/INR",
            "ETH/INR",
            "FTM/INR",
            "LRC/INR",
            "LTC/INR",
            "MKR/INR",
            "OGN/INR",
            "OMG/INR",
            "REQ/INR",
            "SXP/INR",
            "TRX/INR",
            "UMA/INR",
            "UNI/INR",
            "XLM/INR",
            "XRP/INR",
            "YFI/INR",
            "ZRX/INR",
            "BICO/INR",
            "COMP/INR",
            "COTI/INR",
            "DOGE/INR",
            "GALA/INR",
            "IOST/INR",
            "PEPE/INR",
            "SAND/INR",
            "USDT/INR",
            "YFII/INR",
            "1INCH/INR",
            "ALICE/INR",
            "JASMY/INR",
            "MATIC/INR"
        ]
    }
}

import requests
import json
from urllib.parse import urlparse, urlencode


url = "https://coinswitch.co/trade/api/v2/exchangePrecision"

payload = {
    "exchange": "coinswitchx",
    "symbol": "BTC/INR"
}

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("POST", url, headers=headers, json=payload)

   public String getExchangePrecision() throws Exception {
        HashMap<String, String> parameters = new HashMap<>();
        HashMap<String, Object> payload = new HashMap<>();
        payload.put("exchange","coinswitchx");
        payload.put("symbol","BTC/INR");
        String response = this.makeRequest("POST","/trade/api/v2/exchangePrecision", payload, parameters);

        return response;
    }

{
   "data":{
      "coinswitchx":{
         "BTC/INR":{
            "base":5,
            "quote":2,
            "limit":0
         }
      }
   }
}

import requests
import json

url = "https://coinswitch.co/trade/api/v2/tradeInfo"

params = {
  "exchange": "coinswitchx",
  "symbol": "BTC/INR"
}

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("GET", url, headers=headers, params=params)

   public String getTradeInfo() throws Exception {
         HashMap<String, String> parameters = new HashMap<>();
         HashMap<String, Object> payload = new HashMap<>();
         parameters.put("exchange","coinswitchx");
         parameters.put("symbol","BTC/INR");
         String response = this.makeRequest("GET","/trade/api/v2/tradeInfo", payload, parameters);
         return response;
   }

{
  "data": {
    "coinswitchx": {
      "BTC/INR": {
        "quote": {
          "min": "150",
          "max": "2500000"
        },
        "precision": {
          "base": 6,
          "quote": 2,
          "limit": 0
        }
      }
    }
  }
}

import requests
import json

url = "https://coinswitch.co/trade/api/v2/tradingFee"

params = {
  "exchange": "coinswitchx",
}

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-APIKEY': <api-key>
  'X-AUTH-SIGNATURE': <signature>
}

response = requests.request("GET", url, headers=headers, params=params)

   public String getTradingFee() throws Exception {
         HashMap<String, String> parameters = new HashMap<>();
         HashMap<String, Object> payload = new HashMap<>();
         parameters.put("exchange","coinswitchx");
         String response = this.makeRequest("GET", "/trade/api/v2/tradingFee", payload, parameters);
         return response;
   }

{
    "data": {
        "coinswitchx": {
            "AVAX": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "AXP": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "AXS": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "ETH": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "FIL": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "PENDLE": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "SHIB": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "USDT": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            },
            "YFI": {
                "maker_fee": 0.0009,
                "taker_fee": 0.0009,
                "maker_discount_percentage": 100,
                "taker_discount_percentage": 100,
                "maker_fee_after_discount": 0,
                "taker_fee_after_discount": 0,
                "timestamp": 1721909805
            }
        }
    }
}

import requests
import json

url = "https://coinswitch.co/trade/api/v2/order"

payload = {
   "side":"sell",
   "symbol":"BTC/USDT",
   "type":"limit",
   "price":26000,
   "quantity":0.0009,
   "exchange":"c2c1"
}

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("POST", url, headers=headers, json=payload)

   public String createOrder() throws  Exception{
        HashMap<String, String> parameters = new HashMap<>();
        HashMap<String, Object> payload = new HashMap<>();

        payload.put("side", "sell");
        payload.put("symbol", "BTC/USDT");
        payload.put("type", "limit");
        payload.put("quantity", 0.0009);
        payload.put("price", 26000);
        payload.put("exchange", "c2c1");
        DecimalFormat decimalFormat = new DecimalFormat("#.################");
        String formattedQuantity = decimalFormat.format(payload.get("quantity"));
        String formattedPrice = decimalFormat.format(payload.get("price"));
        BigDecimal price = new BigDecimal(formattedPrice);
        BigDecimal quantity = new BigDecimal(formattedQuantity);
        payload.put("quantity", quantity);
        payload.put("price", price);
        return this.makeRequest("POST", "/trade/api/v2/order", payload, parameters);
    }

RESPONSE 200

{
   "data":{
      "order_id":"927db2d9-643c-47a3-9c0f-78741ac95cf5",
      "symbol":"BTC/USDT",
      "price":26000, # price at which Order was placed by the user
      "average_price":0, # price at which the order got executed
      "orig_qty":0.0009, # quantity at which order was placed
      "executed_qty":0, # quantity that got executed
      "status":"OPEN",
      "side":"SELL",
      "exchange":"c2c1",
      "order_source":"API_TRADING",
      "created_time":1689661638000, # time stamp in milli seconds 
      "updated_time":1689661639000   # time stamp in milli seconds
   }
}

RESPONSE: 422
{ 
"message": "Input price must be of type number"
}

RESPONSE: 400
{ 
"message": "Amount is more than available balance" 
}

RESPONSE: 401
{ 
"message": "Invalid access" 
}

import requests
import json

url = "https://coinswitch.co/trade/api/v2/order"

payload = {
    "order_id": "698ed406-8ef5-4664-9779-f7978702a447"
}

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("DELETE", url, headers=headers, json=payload)

public String cancelOrder() throws  Exception{
        HashMap<String, String> parameters = new HashMap<>();
        HashMap<String, Object> payload = new HashMap<>();
        payload.put("order_id", "698ed406-8ef5-4664-9779-f7978702a447");
        return this.makeRequest("DELETE", "/trade/api/v2/order", payload, parameters);
    }

RESPONSE 200
{
   "data":{
      "order_id":"698ed406-8ef5-4664-9779-f7978702a447",
      "symbol":"BTC/INR",
      "price":2300000, # price at which Order was placed by the user
      "average_price":0, # price at which the order got executed
      "orig_qty":5e-05, # quantity at which order was placed
      "executed_qty":0, # quantity that got executed
      "status":"CANCELLED",
      "side":"SELL",
      "exchange":"coinswitchx",
      "order_source":"API_TRADING",
      "created_time":1689661638000, # time stamp in milli seconds 
      "updated_time":1689661639000   # time stamp in milli seconds
   }
}

import requests
import json
from urllib.parse import urlparse, urlencode

params = {
    "order_id": "698ed406-8ef5-4664-9779-f7978702a447",
}
payload = {}

endpoint = "/trade/api/v2/order"

endpoint += ('&', '?')[urlparse(endpoint).query == ''] + urlencode(params)

url = "https://coinswitch.co" + endpoint

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("GET", url, headers=headers, json=payload)

public String getOrder() throws Exception {
    HashMap<String, String> parameters = new HashMap<>();
    HashMap<String, Object> payload = new HashMap<>();

    String path = "?&order_id=" + URLEncoder.encode("698ed406-8ef5-4664-9779-f7978702a447", "UTF-8");
    path = path.replaceAll("%2C", ",");
    path = path.replaceAll("%2F", "/");

    return this.makeRequest("GET","/trade/api/v2/order" + path, payload, parameters);
    }

Response 200
{
   "data":{
      "order_id":"698ed406-8ef5-4664-9779-f7978702a447",
      "symbol":"BTC/USDT",
      "price":27000,
      "average_price":"0",
      "orig_qty":37.79055,
      "executed_qty":0,
      "status":"OPEN",
      "side":"SELL",
      "exchange":"c2c1",
      "order_source":"API_TRADING",
      "created_time":1695365983000,
      "updated_time":1695365983000
   }
}

import requests
import json
from urllib.parse import urlparse, urlencode

params = {
    "count": 2,
    "from_time": 1600261657954,
    "to_time": 1687261657954,
    "side": "sell",
    "symbols": "btc/inr,eth/inr",
    "exchanges": "coinswitchx,wazirx",
    "type": "limit",
    "open": True
}

payload = {}

endpoint = "/trade/api/v2/orders"

endpoint += ('&', '?')[urlparse(endpoint).query == ''] + urlencode(params)

url = "https://coinswitch.co" + endpoint

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("GET", url, headers=headers, json=payload)

public String getOpenOrders() throws Exception {
    HashMap<String, String> parameters = new HashMap<>();
    HashMap<String, Object> payload = new HashMap<>();

    String path = "?&count=" + URLEncoder.encode("2", "UTF-8")
            + "&from_time=" + URLEncoder.encode("1600261657954", "UTF-8")+
            "&to_time=" + URLEncoder.encode("1687261657954", "UTF-8")+
            "&side=" + URLEncoder.encode("sell", "UTF-8")+
            "&type=" + URLEncoder.encode("limit", "UTF-8")+
            "&exchanges=" + URLEncoder.encode("coinswitchx,wazirx", "UTF-8")+
            "&symbols=" + URLEncoder.encode("btc/inr,eth/inr", "UTF-8")+
            "&open=" + URLEncoder.encode(True, "UTF-8")
            ;
    path = path.replaceAll("%2C", ",");
    path = path.replaceAll("%2F", "/");

    return this.makeRequest("GET","/trade/api/v2/orders" + path, payload, parameters);
    }

Response 200
{
  "data": {
    "orders": [
      {
        "order_id": "56013d06-7fe6-416f-9086-86902577ba99",
        "symbol": "SHIB/INR",
        "price": 0.000638,
        "average_price": 0.000957,
        "orig_qty": 187400,
        "executed_qty": 0,
        "status": "OPEN",
        "side": "SELL",
        "exchange": "coinswitchx",
        "order_source": "API_TRADING",
        "created_time": 1687173658000,
        "updated_time": 1687173705000
      },
      {
        "order_id": "87a1b145-84f4-4e8b-8199-0dd0fab2a5ec",
        "symbol": "SHIB/INR",
        "price": 0.000247,
        "average_price": 0,
        "orig_qty": 177400,
        "executed_qty": 167400,
        "status": "PARTIALLY_EXECUTED",
        "side": "SELL",
        "exchange": "coinswitchx",
        "order_source": "API_TRADING",
        "created_time": 1687171873000,
        "updated_time": 1687173633000
      }
    ]
  }
}

# If no orders are present 

Response 200
{
  "data": {
    "orders": []
  }
}

import requests
import json
from urllib.parse import urlparse, urlencode

params = {
    "count": 3,
    "from_time": 1600261657954,
    "to_time": 1687261657954,
    "side": "sell",
    "symbols": "btc/inr,eth/inr",
    "exchanges": "coinswitchx,wazirx",
    "type": "limit",
    "status": "EXECUTED",
    "open": False
}
payload = {}

endpoint = "/trade/api/v2/orders"

endpoint += ('&', '?')[urlparse(endpoint).query == ''] + urlencode(params)

url = "https://coinswitch.co" + endpoint

headers = {
  'Content-Type': 'application/json',
  'X-AUTH-SIGNATURE': <api-signature>,
  'X-AUTH-APIKEY': <api-key>
}

response = requests.request("GET", url, headers=headers, json=payload)

 public String getClosedOrders() throws Exception {
    HashMap<String, String> parameters = new HashMap<>();
    HashMap<String, Object> payload = new HashMap<>();
    String path = "?&count=" + URLEncoder.encode("3", "UTF-8")+
            "&from_time=" + URLEncoder.encode("1600261657954", "UTF-8")+
            "&to_time=" + URLEncoder.encode("1687261657954", "UTF-8")+
            "&side=" + URLEncoder.encode("sell", "UTF-8")+
            "&type=" + URLEncoder.encode("limit", "UTF-8")+
            "&exchanges=" + URLEncoder.encode("coinswitchx,wazirx", "UTF-8")+
            "&symbols=" + URLEncoder.encode("btc/inr,eth/inr", "UTF-8")+
            "&status=" + URLEncoder.encode("EXECUTED", "UTF-8")+
            "&open=" + URLEncoder.encode(False, "UTF-8")
            ;
    path = path.replaceAll("%2C", ",");
    path = path.replaceAll("%2F", "/");

    return this.makeRequest("GET","/trade/api/v2/orders" + path, payload, parameters);
    }

Response 200
{
  "data": {
    "orders": [
      {
        "order_id": "56013d06-7fe6-416f-9086-86902577ba99",
        "symbol": "SHIB/INR",
        "price": 0.000638,
        "average_price": 0.000957,
        "orig_qty": 187400,
        "executed_qty": 0,
        "status": "CANCELLED",
        "side": "SELL",
        "exchange": "coinswitchx",
        "order_source": "API_TRADING",
        "created_time": 1687173658000,
        "updated_time": 1687173705000
      },
      {
        "order_id": "87a1b145-84f4-4e8b-8199-0dd0fab2a5ec",
        "symbol": "SHIB/INR",
        "price": 0.000247,
        "average_price": 0,
        "orig_qty": 177400,
        "executed_qty": 167400,
        "status": "CANCELLED",
        "side": "SELL",
        "exchange": "coinswitchx",
        "order_source": "API_TRADING",
        "created_time": 1687171873000,
        "updated_time": 1687173633000
      },
      {
        "order_id": "47a1b145-84f4-4e8b-8199-0dd0fab2a5ec",
        "symbol": "SHIB/INR",
        "price": 0.000247,
        "average_price": 0,
        "orig_qty": 177400,
        "executed_qty": 177400,
        "status": "EXECUTED",
        "side": "BUY",
        "exchange": "coinswitchx",
        "order_source": "API_TRADING",
        "created_time": 1687171873000,
        "updated_time": 1687173633000
      }
    ]
  }
}

# If no orders are present 

Response 200
{
  "data": {
    "orders": []
  }
}