GO thread safe library (WebSockets / HTTP) for Bitvavo v2 API (see: https://docs.bitvavo.com)
Listen to all events occurring on the Bitvavo platform (tickers, tickers24h, candles, books, trades, orders, fills) using websockets. With the HTTP client you can do things like placing orders or withdraw assets from your account.
- WebSocket Listeners -- Read only
- Book
- Candles
- Trades
- Ticker
- Ticker 24h
- Orders/Fills
- HTTP Client -- Read / Write
- Market data endpoints
- Account endpoints
- Synchronization endpoints
- Trading endpoints
- Transfer endpoints
go get github.com/larscom/bitvavo-go/v2@latestimport "github.com/larscom/bitvavo-go/v2/pkg/bitvavo"For each event on the Bitvavo platform there is a listener available. A listener wraps a websocket connection, you can also implement your own wrapper arround the websocket. The listeners handle everything for you, like resubscribing and reauthenticating when the connection has been lost.
- BookListener
- CandlesListener
- TickerListener
- Ticker24hListener
- TradesListener
package main import "github.com/larscom/bitvavo-go/v2/pkg/bitvavo" func main() { // listen for candle (public) events listener := bitvavo.NewCandlesListener() defer listener.Close() chn, err := listener.Subscribe([]string{"ETH-EUR"}, []bitvavo.Interval{bitvavo.Interval1m}) if err != nil { panic(err) } for event := range chn { if event.Error != nil { panic(event.Error) } log.Println(event.Value) } }- OrderListener
- FillListener
package main import "github.com/larscom/bitvavo-go/v2/pkg/bitvavo" func main() { // listen for order (private) events listener := bitvavo.NewOrderListener("MY_API_KEY", "MY_API_SECRET") defer listener.Close() chn, err := listener.Subscribe([]string{"ETH-EUR"}) if err != nil { panic(err) } for event := range chn { if event.Error != nil { panic(event.Error) } log.Println(event.Value) } }You can add the debug printer option to enable debug logging for websockets. There is a default printer, but you can also provide your own as long as it implements the DebugPrinter interface.
package main import "github.com/larscom/bitvavo-go/v2/pkg/bitvavo" func main() { listener := bitvavo.NewCandlesListener(bitvavo.WithWebSocketDefaultDebugPrinter()) }You can provide your own http client from the net/http package which will be used to set up the initial websocket connection.
package main import ( "net/http" "github.com/larscom/bitvavo-go/pkg/bitvavo/v2" ) func main() { listener := bitvavo.NewCandlesListener(bitvavo.WithWebSocketHttpClient(http.DefaultClient)) }It's possible to create your own wrapper arround the websocket and listen to multiple events at the same time.
package main import "github.com/larscom/bitvavo-go/v2/pkg/bitvavo" func main() { onMessage := func(data bitvavo.WebSocketEventData, err error) { if err != nil { // oh no error! } else if data.Event == bitvavo.EventBook { // decode into Book var book bitvavo.Book data.Decode(&book) } else if data.Event == bitvavo.EventCandle { // decode into Candle var candle bitvavo.Candle data.Decode(&candle) } // etc } onReconnect := func() { // gets called when successfully reconnected } ws, err := bitvavo.NewWebSocket(context.Background(), onMessage, onReconnect) // do stuff with ws }The HTTP client implements 2 interfaces (PrivateAPI and PublicAPI)
If you need both private and public endpoints you can create a private http client as it includes both public and private endpoints.
package main import "github.com/larscom/bitvavo-go/v2/pkg/bitvavo" func main() { // private http client (includes public as well) client := bitvavo.NewPrivateHTTPClient("MY_API_KEY", "MY_API_SECRET") orders, err := client.GetOrders(context.Background(), "ETH-EUR") if err != nil { log.Fatal(err) } log.Println("Orders", orders) }package main import "github.com/larscom/bitvavo-go/v2/pkg/bitvavo" func main() { // public http client client := bitvavo.NewPublicHTTPClient() markets, err := client.GetMarkets(context.Background()) if err != nil { log.Fatal(err) } log.Println("Markets", markets) }Some endpoints have additional params which you can provide.
package main import "github.com/larscom/bitvavo-go/v2/pkg/bitvavo" func main() { client := bitvavo.NewPublicHTTPClient() // limit to 100 trades params := &bitvavo.TradeParams{ Limit: 100, } trades, err := client.GetTrades(context.Background(), "ETH-EUR", params) }You can provide your own http client from the net/http package which will be used to execute all requests.
package main import ( "net/http" "github.com/larscom/bitvavo-go/pkg/bitvavo/v2" ) func main() { client := bitvavo.NewPublicHTTPClient(bitvavo.WithHttpClient(http.DefaultClient)) }You can provide your own window time which specifies the maximum allowed deviation (in milliseconds) between the timestamp you sent and the server's actual time when processing your request.
The default window time is: 10000 (10 seconds)
package main import ( "github.com/larscom/bitvavo-go/pkg/bitvavo/v2" ) func main() { client := bitvavo.NewPrivateHTTPClient("MY_API_KEY", "MY_API_SECRET", bitvavo.WithWindowTime(5000)) }You can add the debug printer option to enable debug logging for http. There is a default printer, but you can also provide your own as long as it implements the DebugPrinter interface.
package main import ( "github.com/larscom/bitvavo-go/pkg/bitvavo/v2" ) func main() { client := bitvavo.NewPrivateHTTPClient("MY_API_KEY", "MY_API_SECRET", bitvavo.WithDefaultDebugPrinter()) }There is an example that uses the ticker listener for ticker events and HTTP client to retrieve the trading markets.
You can run this example by cloning this project and running:
make run or without make: go run ./example/main.go
This command will subscribe to all available trading markets and log the received tickers.
If you want to test private endpoints and listeners you can place a .env file in the root of the project.
.env file
API_KEY=MY_API_KEY API_SECRET=MY_API_SECRET