Binance API and Node.js: Harnessing Power for Cryptocurrency Trading Applications
The cryptocurrency market has seen unprecedented growth since its inception, with digital assets now occupying a significant share in global markets. Among the key players in this space is Binance, one of the world's largest crypto exchanges. Its APIs allow developers to interact with Binance’s platform programmatically for a plethora of applications ranging from simple portfolio tracking to more complex trading strategies. In this article, we will explore how to use Node.js, an efficient and popular backend language, to connect and work with Binance API.
Understanding Binance APIs
Binance provides a suite of APIs that cater to different levels of user needs - from simple GET requests for basic data to the more complex trading and withdrawal services. The main APIs include:
1. Public API: This is used for obtaining real-time information such as order book depth, recent trades, and coin pair prices etc.
2. WebSocket API: Allows 24/7 live streaming of market data in real time, ideal for applications that need to react quickly to market changes.
3. Private API: Requires API keys and authentication for trading features such as placing orders, checking balances, and executing trades.
Node.js and Binance APIs
Node.js is an open-source JavaScript runtime environment that executes code in a single-threaded event loop designed to build non-blocking I/O applications. It allows developers to interact with web servers efficiently using the language of their choice, in this case, JavaScript or TypeScript.
Connecting to Binance Public API with Node.js
Firstly, we need to install and configure the Axios library which is a promise-based HTTP client for JavaScript. It allows us to make requests to APIs and services:
```bash
npm install axios
```
Now let's write our first public API request script using Node.js. The following code snippet uses 'axios' to fetch the latest data from Binance’s order book of BTC-USDT trading pair.
```javascript
const axios = require('axios');
const https = require('https');
// Using https agent to create a secure connection
https.globalAgent.maxSockets = Infinity;
const apiUrl = 'https://api.binance.com/api/v3';
let baseurl="public/exchangeInfo?symbol=BTCUSDT";
axios.get(apiUrl+baseurl)
.then(response => {
console.log(JSON.stringify(response.data,null,2));
})
.catch(function (error) {
if (error.response) {
// The request was made and the server responded with a status code
// that falls out of the range of 2xx
console.log('Error:' + JSON.stringify(error.response));
} else if (error.request) {
// The request was made but no response was received
// `error.request` is an object that comes back with all of the data.
console.error('No Response:'+error.request);
} else {
// Something happened in setting up the request that triggered an Error
console.error('Error', error.message);
}
});
```
Binance WebSocket API with Node.js
Binance also provides a WebSocket API for 24/7 real-time streaming of market data. Here is how to connect Node.js with Binance’s WSS:
1. Install the 'ws' library using npm to handle WebSockets:
```bash
npm install ws
```
2. Use the following script as an example. This connects to the BTC-USDT trading pair and logs out every trade update it gets:
```javascript
const { createServer } = require('ws');
const axios = require("axios");
const WebSocket = require('ws');
// Creating a new instance of ws
const wss = createServer({ server: 'wss://fstream.binance.com' });
const getBinanceStream = (symbol) => {
return axios.get(`https://fapi.binance.com/fapi/v1?symbol=${symbol}&type=TRADE`, {
headers: {
'X-MB-SIGN': '',
'Content-Type': 'application/json'
}
});
};
wss.on('connection', ws => {
ws.on('message', message => {
console.log(JSON.parse(message));
});
getBinanceStream('BTCUSDT').then((response) => {
if (response && response.data){
ws.send(JSON.stringify(response.data));
}
}).catch(err => console.log(err))
});
```
This script connects to the BTC-USDT trading pair, listens for incoming messages on a WebSocket connection and then logs out each trade update it gets from Binance's API.
Binance Private API with Node.js
Binance’s private APIs are only available after authentication. To access these features, developers need to sign up at Binance and get an API key. This involves creating a Binance account, navigating to the ‘API Trading’ section in your account settings, and then applying for keys for both the public and private APIs.
For the private API, Node.js uses Axios or other libraries to make requests with a signature of the API key and secret. Here's an example:
```javascript
const axios = require('axios');
const https = require('https');
https.globalAgent.maxSockets = Infinity;
// Create a new instance of Axios
let axiosInstance = axios.create({
baseURL:'https://fapi.binance.com',
headers: {
'X-MB-APIKEY': 'Your API Key',
'X-MB-SECRET': 'Your Secret Key'
}
});
// Now we can call the APIs
axiosInstance.get('/fapi/v1/account')
.then(response => {
console.log('Response: ' + JSON.stringify(response));
})
.catch(function (error) {
if (error.response) {
// The request was made and the server responded with a status code that falls out of the range of 2xx
console.log(`Error Response Code: ${error.response.status}`);
console.log(`Error Text: ${error.response.data}`);
} else if (error.request) {
// The request was made but no response was received
// `error.request` is an object that comes back with all of the data.
console.log("No Response", error.request);
} else {
// Something happened in setting up the request that triggered an Error
console.log('Error', error.message);
}
});
```
In this script, we create a new instance of Axios with our API key and secret as headers. Then, we can make requests to Binance’s private APIs, in this case, the account information endpoint.
In conclusion, Node.js' event-driven architecture makes it an excellent choice for creating real-time trading applications that utilize Binance’s WebSocket APIs. Its powerful libraries and comprehensive tooling support allow developers to create efficient, scalable solutions to meet their unique needs in the fast-paced cryptocurrency market.