ccxt/go-binance — 1.9k Stars

Topics

#api #binance #bitcoin #btc #eth #exchange #go #golang #sdk

Language breakdown

No language data available.

▸ Files click to expand

README

go-binance

A Golang SDK for binance API.

All the REST APIs listed in binance API document are implemented, as well as the websocket APIs.

For best compatibility, please use Go >= 1.8.

Make sure you have read binance API document before continuing.

Community

Join our growing community on Telegram to get help, or just chat!

https://t.me/gobinancegroup

API List

Name | Description | Status ------------ | ------------ | ------------ rest-api.md | Details on the Rest API (/api) | Implemented web-socket-streams.md | Details on available streams and payloads | Implemented user-data-stream.md | Details on the dedicated account stream | Implemented margin-api.md | Details on the Margin API (/sapi) | Implemented futures-api.md | Details on the Futures API (/fapi) | Implemented delivery-api.md | Details on the Coin-M Futures API (/dapi) | Implemented options-api.md | Details on the Options API(/eapi) | Implemented portfolio-margin-api.md | Details on the Portfolio Margin API(/papi) | Implemented

If you find an unimplemented interface, please submit an issue. It's great if you can open a PR to fix it.

Installation

go get github.com/adshao/go-binance/v2

For v1 API, it has been moved to v1 branch, please use:

go get github.com/adshao/go-binance/v1

Importing

import (
    // for spot and other interfaces contained in https://binance-docs.github.io/apidocs/spot/en/#change-log
    "github.com/adshao/go-binance/v2"
"github.com/adshao/go-binance/v2/futures" // optional package     "github.com/adshao/go-binance/v2/delivery" // optional package     "github.com/adshao/go-binance/v2/options" // optional package )

Documentation

REST API

Setup

Init client for API services. Get APIKey/SecretKey from your binance account.

var (
    apiKey = "your api key"
    secretKey = "your secret key"
)
client := binance.NewClient(apiKey, secretKey)
futuresClient := binance.NewFuturesClient(apiKey, secretKey)    // USDT-M Futures
deliveryClient := binance.NewDeliveryClient(apiKey, secretKey)  // Coin-M Futures

A service instance stands for a REST API endpoint and is initialized by client.NewXXXService function.

Simply call API in chain style. Call Do() in the end to send HTTP request.

Following are some simple examples, please refer to godoc for full references.

If you have any questions, please refer to the specific version of the code for specific reference definitions or usage methods

Proxy Client

proxyUrl := "http://127.0.0.1:7890" // Please replace it with your exact proxy URL.
client := binance.NewProxiedClient(apiKey, apiSecret, proxyUrl)

Create Order

order, err := client.NewCreateOrderService().Symbol("BNBETH").
        Side(binance.SideTypeBuy).Type(binance.OrderTypeLimit).
        TimeInForce(binance.TimeInForceTypeGTC).Quantity("5").
        Price("0.0030000").Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(order)
// Use Test() instead of Do() for testing.

Get Order

order, err := client.NewGetOrderService().Symbol("BNBETH").
    OrderID(4432844).Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(order)

Cancel Order

_, err := client.NewCancelOrderService().Symbol("BNBETH").
    OrderID(4432844).Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}

List Open Orders

openOrders, err := client.NewListOpenOrdersService().Symbol("BNBETH").
    Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
for _, o := range openOrders {
    fmt.Println(o)
}

List Orders

orders, err := client.NewListOrdersService().Symbol("BNBETH").
    Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
for _, o := range orders {
    fmt.Println(o)
}

List Ticker Prices

prices, err := client.NewListPricesService().Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
for _, p := range prices {
    fmt.Println(p)
}

Show Depth

res, err := client.NewDepthService().Symbol("LTCBTC").
    Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(res)

List Klines

klines, err := client.NewKlinesService().Symbol("LTCBTC").
    Interval("15m").Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
for _, k := range klines {
    fmt.Println(k)
}

List Aggregate Trades

trades, err := client.NewAggTradesService().
    Symbol("LTCBTC").StartTime(1508673256594).EndTime(1508673256595).
    Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
for _, t := range trades {
    fmt.Println(t)
}

Get Account

res, err := client.NewGetAccountService().Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(res)

Start User Stream

res, err := client.NewStartUserStreamService().Do(context.Background())
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(res)

Websocket

You don't need Client in websocket API. Just call binance.WsXxxServe(args, handler, errHandler).

For delivery API you can use delivery.WsXxxServe(args, handler, errHandler).

If you want to use a proxy, you can set HTTPSPROXY or HTTPPROXY in the environment variable, or you can call SetWsProxyUrl in the target packages within your code. Then you can call other websocket functions. For example:

binance.SetWsProxyUrl("http://127.0.0.1:7890") binance.WsDepthServe("LTCBTC", wsDepthHandler, errHandler)

Depth

wsDepthHandler := func(event *binance.WsDepthEvent) {
    fmt.Println(event)
}
errHandler := func(err error) {
    fmt.Println(err)
}
doneC, stopC, err := binance.WsDepthServe("LTCBTC", wsDepthHandler, errHandler)
if err != nil {
    fmt.Println(err)
    return
}
// use stopC to exit
go func() {
    time.Sleep(5 * time.Second)
    stopC <- struct{}{}
}()
// remove this if you do not want to be blocked here
<-doneC

Kline

wsKlineHandler := func(event *binance.WsKlineEvent) {
    fmt.Println(event)
}
errHandler := func(err error) {
    fmt.Println(err)
}
doneC, _, err := binance.WsKlineServe("LTCBTC", "1m", wsKlineHandler, errHandler)
if err != nil {
    fmt.Println(err)
    return
}
<-doneC

Aggregate

wsAggTradeHandler := func(event *binance.WsAggTradeEvent) {
    fmt.Println(event)
}
errHandler := func(err error) {
    fmt.Println(err)
}
doneC, _, err := binance.WsAggTradeServe("LTCBTC", wsAggTradeHandler, errHandler)
if err != nil {
    fmt.Println(err)
    return
}
<-doneC

User Data

⚠️ Deprecated: The listen key method (WsUserDataServe) is deprecated. Use WsUserDataServeSignature instead.

Recommended Method (Websocket API):

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "github.com/adshao/go-binance/v2"
)
// Handler for user data events userDataHandler := func(event *binance.WsUserDataEvent) {     fmt.Printf("Event: %s, Time: %d\n", event.Event, event.Time)          switch event.Event {     case binance.UserDataEventTypeOutboundAccountPosition:         fmt.Printf("Account Update: %+v\n", event.AccountUpdate)     case binance.UserDataEventTypeBalanceUpdate:         fmt.Printf("Balance Update: %+v\n", event.BalanceUpdate)     case binance.UserDataEventTypeExecutionReport:         fmt.Printf("Order Update: %+v\n", event.OrderUpdate)     case binance.UserDataEventTypeListStatus:         fmt.Printf("OCO Update: %+v\n", event.OCOUpdate)     } }
errHandler := func(err error) {     fmt.Println(err) }
// Connect using signature-based authentication (recommended) doneC, stopC, err := binance.WsUserDataServeSignature(     apiKey,           // Your API key     secretKey,        // Your secret key     keyType,          // "HMAC", "RSA", or "ED25519" (empty string for HMAC)     timeOffset,       // Time offset in milliseconds (usually 0)     userDataHandler,  // Event handler     errHandler,       // Error handler ) if err != nil {     fmt.Println(err)     return } <-doneC

Setting Server Time

Your system time may be incorrect and you may use following function to set the time offset based off Binance Server Time:

// use the client future for Futures
client.NewSetServerTimeService().Do(context.Background())

Or you can also overwrite the TimeOffset yourself:

client.TimeOffset = 123

Testnet

You can use the testnet by enabling the corresponding flag.

Note that you can't use your regular API and Secret keys for the testnet. You have to create an account on

the testnet websites : https://testnet.binancefuture.com/ for futures and delivery

or https://testnet.binance.vision/ for the Spot Test Network.

Spot

Use the binance.UseTestnet flag before calling the client creation and the websockets methods.

import (
    "github.com/adshao/go-binance/v2"
)
binance.UseTestnet = true client := binance.NewClient(apiKey, secretKey)

Futures (usd(s)-m futures)

Use the futures.UseTestnet flag before calling the client creation and the websockets methods

import (
    "github.com/adshao/go-binance/v2/futures"
)
futures.UseTestnet = true BinanceClient = futures.NewClient(ApiKey, SecretKey)

Delivery (coin-m futures)

Use the delivery.UseTestnet flag before calling the client creation and the websockets methods

import (
    "github.com/adshao/go-binance/v2/delivery"
)
delivery.UseTestnet = true BinanceClient = delivery.NewClient(ApiKey, SecretKey)

Websocket client

Order place

Async write/read

func main() {
    orderPlaceService, _ := futures.NewOrderPlaceWsService(apiKey, secretKey)
    
    ctx, cancel := context.WithCancel(context.Background())
    
    c := make(chan os.Signal, 1)
    signal.Notify(c, os.Interrupt)
    go func() {
        select {
            case <-c:
            cancel()
        }
    }()
request := futures.NewOrderPlaceWsRequest()     request.         Symbol("BTCUSDT").         Side(futures.SideTypeSell).         Type(futures.OrderTypeLimit).         Price("68198.00").         Quantity("0.002").         TimeInForce(futures.TimeInForceTypeGTC)
// sender     go func() {         for {             select {             case <-ctx.Done():                 return             default:                 err := orderPlaceService.Do("id", request)                 if err != nil {                     return                 }             }         }     }()
wg := &sync.WaitGroup{}     wg.Add(1)     go listenOrderPlaceResponse(ctx, wg, orderPlaceService)     wg.Wait()
log.Println("exit") }
func listenOrderPlaceResponse(ctx context.Context, wg sync.WaitGroup, orderPlaceService futures.OrderPlaceWsService) {     defer wg.Done()
go func() {         for msg := range orderPlaceService.GetReadChannel() {             log.Println("order place response", string(msg))         }     }()
go func() {         for err := range orderPlaceService.GetReadErrorChannel() {             log.Println("order place error", err)         }     }()
select {     case <-ctx.Done():         orderPlaceService.ReceiveAllDataBeforeStop(10 * time.Second)     } }

Sync write/read

func main() {     orderPlaceService, _ := futures.NewOrderPlaceWsService(apiKey, secretKey)
id := "some-id"     request := futures.NewOrderPlaceWsRequest()     request.         Symbol("BTCUSDT").         Side(futures.SideTypeSell).         Type(futures.OrderTypeLimit).         Price("68198.00").         Quantity("0.002").         TimeInForce(futures.TimeInForceTypeGTC)
response, err := orderPlaceService.SyncDo(id, request)     if err != nil {         log.Fatal(err)     }
// handle response }

Star history

Check out some of the other packages

Check out CCXT for more than 100 crypto exchanges with a unified trading API in 5 different languages.
Check out Python-Binance for a complete Python Wrapper.
Check out Node-Binance-API for a node.js sdk.
Check out Binance-Trade-Bot for a binance bot in python

🔗 More in this category