bybit

package module

v1.0.0 Latest Latest Go to latest Published: Jan 18, 2026 License: MIT Imports: 18 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/tigusigalpa/bybit-go

Links

Open Source Insights

README ¶

🚀 Bybit Go SDK

⚡ Lightning-Fast V5 API Client for Golang

Bybit Golang SDK

╔══════════════════════════════════════════════════════════════╗
║  🎯 Production-Ready • 🔒 Secure • ⚡ High-Performance      ║
║  💎 Type-Safe • 🌍 Global • 🔄 Real-Time WebSocket          ║
╚══════════════════════════════════════════════════════════════╝

Transform your trading ideas into reality with the most powerful Go SDK for Bybit V5 API

🚀 Quick Start • 📚 Documentation • 💡 Examples • 🌟 Features

🎯 Why Choose Bybit Go SDK?

🚀 Go Native

Built from ground up for Golang, leveraging goroutines, channels, and idiomatic patterns

⚡ Blazing Fast

Optimized for low-latency trading with concurrent-safe operations

🔒 Bank-Grade Security

HMAC-SHA256 & RSA-SHA256 signatures with best practices

💪 Built for Real Traders

"Stop wrestling with API documentation. Start building profitable trading strategies."

🤖 For Algorithmic Traders

✨ Execute complex strategies with millisecond precision
📊 Real-time market data streaming via WebSocket
🎯 Advanced order types: Limit, Market, Trigger, TP/SL
🔄 Automatic position management and risk controls
📈 Built-in fee calculation for accurate P&L tracking

👨‍💻 For Developers

🛡️ Type-safe operations eliminate runtime errors
🧪 Testnet support for risk-free development
📦 Zero dependencies except gorilla/websocket
🔧 Flexible configuration with sensible defaults
📖 Comprehensive examples and documentation

🏢 For Production Systems

⚙️ Thread-safe with mutex-protected operations
🔄 Smart reconnection with exponential backoff
📝 Detailed error messages for debugging
🌍 Multi-region support for global deployment
🚦 Rate limit handling built-in

✨ Features That Set Us Apart

🎨 Complete Trading Arsenal

┌─────────────────────────────────────────────────────────────┐
│  📊 Market Data    │  💰 Trading      │  🔐 Security       │
│  • Tickers         │  • Spot          │  • HMAC-SHA256     │
│  • Orderbook       │  • Derivatives   │  • RSA-SHA256      │
│  • Klines          │  • Limit/Market  │  • API Key Mgmt    │
│  • Trades          │  • TP/SL Orders  │  • Secure Storage  │
├─────────────────────────────────────────────────────────────┤
│  🌐 WebSocket      │  ⚙️ Management   │  🌍 Global         │
│  • Real-time       │  • Positions     │  • Multi-region    │
│  • Public Streams  │  • Leverage      │  • Testnet/Mainnet │
│  • Private Streams │  • Risk Control  │  • Low Latency     │
│  • Auto-reconnect  │  • Wallet        │  • 24/7 Trading    │
└─────────────────────────────────────────────────────────────┘

🚀 Performance & Reliability

🎯 Sub-millisecond latency for order execution
🔄 Goroutine-safe concurrent operations
💪 Production-tested in high-frequency environments
📊 Zero-downtime with smart reconnection
⚡ Optimized for minimal memory footprint

💎 Developer Experience

🛠️ Plug & Play - Works out of the box
📚 Rich Examples - Learn by doing
🧪 Testnet First - Test before you invest
🔧 Highly Configurable - Adapt to your needs
📖 Clear Documentation - No guesswork

🎁 Bonus Features

Feature	Description	Status
🔐 Dual Authentication	HMAC-SHA256 & RSA-SHA256 support	✅ Ready
🌍 Global Endpoints	NL, TR, KZ, GE, AE regions	✅ Ready
📡 WebSocket Streams	Real-time data with auto-reconnect	✅ Ready
💰 Fee Calculator	Built-in trading fee computation	✅ Ready
🎯 Smart Orders	Advanced TP/SL with percentage/absolute	✅ Ready
🔄 Position Management	Leverage, hedging, one-way mode	✅ Ready

📦 Installation

Get Started in 30 Seconds ⚡

Step 1: Install the package

go get github.com/tigusigalpa/bybit-go

Step 2: Import and use

import bybit "github.com/tigusigalpa/bybit-go"

Step 3: Start trading! 🚀

📝 Alternative: Manual Installation

Add to your go.mod:

require github.com/tigusigalpa/bybit-go v1.0.0

Then run:

go mod tidy

⚙️ Configuration

🎛️ Flexible Configuration Options

🔑 Quick Setup (Environment Variables)

export BYBIT_API_KEY="your_api_key"
export BYBIT_API_SECRET="your_secret"
export BYBIT_TESTNET="true"
export BYBIT_REGION="global"

💡 Pro Tip: Use .env files for local development

⚙️ Programmatic Configuration

client, err := bybit.NewClient(
    bybit.ClientConfig{
        APIKey:     os.Getenv("BYBIT_API_KEY"),
        APISecret:  os.Getenv("BYBIT_API_SECRET"),
        Testnet:    true,
        Region:     "global",
        RecvWindow: 5000,
        Signature:  "hmac",
    },
)

📋 Configuration Reference

Parameter	Type	Default	Description	Example
`APIKey`	`string`	required	🔑 Your Bybit API public key	`"abc123..."`
`APISecret`	`string`	required	🔐 Your Bybit API secret key	`"xyz789..."`
`Testnet`	`bool`	`false`	🧪 Enable testnet environment	`true`
`Region`	`string`	`"global"`	🌍 Regional endpoint	`"nl"`, `"tr"`, `"kz"`
`RecvWindow`	`int`	`5000`	⏱️ Request receive window (ms)	`10000`
`Signature`	`string`	`"hmac"`	🔏 Signature type	`"hmac"`, `"rsa"`
`RSAPrivateKey`	`string`	`""`	🔑 RSA private key (PEM format)	`"-----BEGIN..."`

🚀 Quick Start

🎬 From Zero to Trading in 3 Minutes

🎯 Example 1: Your First API Call

package main

import (
    "fmt"
    "log"
    
    bybit "github.com/tigusigalpa/bybit-go"
)

func main() {
    // 🎯 Step 1: Initialize client
    client, err := bybit.NewClient(bybit.ClientConfig{
        APIKey:     "your_api_key",
        APISecret:  "your_api_secret",
        Testnet:    true,  // 🧪 Safe testing environment
        Region:     "global",
        Signature:  "hmac",
    })
    if err != nil {
        log.Fatal(err)
    }

    // ✅ Step 2: Verify connection
    serverTime, err := client.GetServerTime()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("✅ Connected! Server Time: %v\n", serverTime)

    // 📊 Step 3: Get real-time market data
    tickers, err := client.GetTickers(map[string]interface{}{
        "category": "linear",
        "symbol":   "BTCUSDT",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("📊 BTC Price: %v\n", tickers)

    // 💰 Step 4: Place your first order
    order, err := client.CreateOrder(map[string]interface{}{
        "category":    "linear",
        "symbol":      "BTCUSDT",
        "side":        "Buy",
        "orderType":   "Limit",
        "qty":         "0.01",
        "price":       "30000",
        "timeInForce": "GTC",
    })
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("🎉 Order placed! ID: %v\n", order["result"].(map[string]interface{})["orderId"])
}

🎊 Congratulations! You just made your first API call!

💡 Example 2: Real-Time WebSocket Streaming

package main

import (
    "fmt"
    "log"
    
    bybit "github.com/tigusigalpa/bybit-go"
)

func main() {
    // 🌐 Create WebSocket connection
    ws := bybit.NewWebSocket(bybit.WebSocketConfig{
        Testnet:   false,
        Region:    "global",
        IsPrivate: false,
    })

    // 📡 Subscribe to real-time data
    ws.SubscribeOrderbook("BTCUSDT", 50)
    ws.SubscribeTrade("BTCUSDT")
    ws.SubscribeTicker("BTCUSDT")

    // 🎧 Listen to market updates
    ws.OnMessage(func(data map[string]interface{}) {
        if topic, ok := data["topic"].(string); ok {
            fmt.Printf("📨 Update from %s: %v\n", topic, data["data"])
        }
    })

    // 🚀 Start streaming
    fmt.Println("🎬 WebSocket streaming started! Press Ctrl+C to stop...")
    if err := ws.Listen(); err != nil {
        log.Fatal(err)
    }
}

⚡ Real-time data streaming in just 20 lines of code!

📚 API Methods

🎨 Complete API Coverage

Every endpoint you need, beautifully wrapped

📊 Market Data

Get real-time prices, orderbooks, and historical data

💰 Trading

Execute orders with precision and speed

🎯 Positions

Manage leverage, TP/SL, and risk

📊 Market Data APIs

Click to expand Market Data methods

// ⏰ Get server time
time, err := client.GetServerTime()

// 📈 Get market tickers (real-time prices)
tickers, err := client.GetTickers(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
})

// 📖 Get orderbook depth
orderbook, err := client.GetOrderbook(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
    "limit":    50,
})

// 📊 Get klines/candlesticks
klines, err := client.GetKlines(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
    "interval": "1",  // 1 minute
    "limit":    200,
})

💰 Order Management APIs

Click to expand Order Management methods

// 📝 Create a new order
order, err := client.CreateOrder(map[string]interface{}{
    "category":    "linear",
    "symbol":      "BTCUSDT",
    "side":        "Buy",      // Buy or Sell
    "orderType":   "Limit",    // Limit, Market, etc.
    "qty":         "0.01",
    "price":       "30000",
    "timeInForce": "GTC",      // Good Till Cancel
})

// 📋 Get all open orders
openOrders, err := client.GetOpenOrders(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
})

// ✏️ Modify an existing order
amended, err := client.AmendOrder(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
    "orderId":  "order_id_here",
    "qty":      "0.02",        // New quantity
    "price":    "31000",       // New price
})

// ❌ Cancel a single order
cancelled, err := client.CancelOrder(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
    "orderId":  "order_id_here",
})

// 🧹 Cancel all orders for a symbol
cancelledAll, err := client.CancelAllOrders(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
})

// 📜 Get order history
history, err := client.GetHistoryOrders(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
    "limit":    50,
})

🎯 Position Management APIs

Click to expand Position Management methods

// 📊 Get current positions
positions, err := client.GetPositions(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
})

// ⚡ Set leverage (1x - 100x)
err := client.SetLeverage("linear", "BTCUSDT", 10.0, nil)

// 🔄 Switch position mode
err := client.SwitchPositionMode(map[string]interface{}{
    "category": "linear",
    "symbol":   "BTCUSDT",
    "mode":     0,  // 0: One-Way Mode, 3: Hedge Mode
})

// 🎯 Set Take Profit & Stop Loss
err := client.SetTradingStop(map[string]interface{}{
    "category":    "linear",
    "symbol":      "BTCUSDT",
    "positionIdx": 0,
    "takeProfit":  "35000",  // Take profit at $35k
    "stopLoss":    "28000",  // Stop loss at $28k
})

💼 Account & Wallet APIs

Click to expand Account & Wallet methods

// 💰 Get wallet balance
balance, err := client.GetWalletBalance(map[string]interface{}{
    "accountType": "UNIFIED",  // UNIFIED, CONTRACT, SPOT
    "coin":        "USDT",
})

// 💵 Calculate trading fees
spotFee := client.ComputeFee("spot", 1000.0, "Non-VIP", "taker")
// Returns: 1.0 USDT (0.1% fee)

derivativesFee := client.ComputeFee("derivatives", 10000.0, "VIP1", "maker")
// Returns: 6.75 USDT (0.0675% fee)

🌐 WebSocket Streaming

Public Streams

package main

import (
    "fmt"
    "log"
    
    bybit "github.com/tigusigalpa/bybit-go"
)

func main() {
    // Create WebSocket instance
    ws := bybit.NewWebSocket(bybit.WebSocketConfig{
        Testnet:   false,
        Region:    "global",
        IsPrivate: false,
    })

    // Subscribe to orderbook
    ws.SubscribeOrderbook("BTCUSDT", 50)

    // Subscribe to trades
    ws.SubscribeTrade("BTCUSDT")

    // Subscribe to ticker
    ws.SubscribeTicker("BTCUSDT")

    // Subscribe to klines
    ws.SubscribeKline("BTCUSDT", "1") // 1m candles

    // Handle messages
    ws.OnMessage(func(data map[string]interface{}) {
        if topic, ok := data["topic"].(string); ok {
            fmt.Printf("Topic: %s\n", topic)
            fmt.Printf("Data: %v\n", data["data"])
        }
    })

    // Start listening (blocking)
    if err := ws.Listen(); err != nil {
        log.Fatal(err)
    }
}

Private Streams

package main

import (
    "fmt"
    "log"
    
    bybit "github.com/tigusigalpa/bybit-go"
)

func main() {
    ws := bybit.NewWebSocket(bybit.WebSocketConfig{
        APIKey:    "your_api_key",
        APISecret: "your_api_secret",
        Testnet:   false,
        Region:    "global",
        IsPrivate: true,
    })

    // Subscribe to position updates
    ws.SubscribePosition()

    // Subscribe to order updates
    ws.SubscribeOrder()

    // Subscribe to execution updates
    ws.SubscribeExecution()

    // Subscribe to wallet updates
    ws.SubscribeWallet()

    ws.OnMessage(func(data map[string]interface{}) {
        topic, _ := data["topic"].(string)
        switch topic {
        case "position":
            handlePositionUpdate(data)
        case "order":
            handleOrderUpdate(data)
        case "execution":
            handleExecutionUpdate(data)
        case "wallet":
            handleWalletUpdate(data)
        }
    })

    if err := ws.Listen(); err != nil {
        log.Fatal(err)
    }
}

💡 Advanced Usage

Universal Order Placement

// Spot limit order
price := 30000.0
order, err := client.PlaceOrder(bybit.PlaceOrderParams{
    Type:      "spot",
    Symbol:    "BTCUSDT",
    Execution: "limit",
    Price:     &price,
    Side:      stringPtr("Buy"),
    Size:      0.01,
})

// Derivatives market order with leverage
leverage := 10.0
tp := 0.02 // 2%
sl := 0.01 // 1%
order, err := client.PlaceOrder(bybit.PlaceOrderParams{
    Type:      "derivatives",
    Symbol:    "BTCUSDT",
    Execution: "market",
    Side:      stringPtr("Buy"),
    Leverage:  &leverage,
    Size:      100.0, // margin in USDT
    SlTp: &bybit.SlTpParams{
        Type:       "percent",
        TakeProfit: &tp,
        StopLoss:   &sl,
    },
})

// Trigger order with absolute TP/SL
triggerPrice := 29500.0
tpAbs := 31000.0
slAbs := 29000.0
order, err := client.PlaceOrder(bybit.PlaceOrderParams{
    Type:      "derivatives",
    Symbol:    "BTCUSDT",
    Execution: "trigger",
    Price:     &triggerPrice,
    Side:      stringPtr("Buy"),
    Leverage:  &leverage,
    Size:      150.0,
    SlTp: &bybit.SlTpParams{
        Type:       "absolute",
        TakeProfit: &tpAbs,
        StopLoss:   &slAbs,
    },
    Extra: map[string]interface{}{
        "timeInForce": "GTC",
    },
})

func stringPtr(s string) *string {
    return &s
}

Trading Fee Calculation

// Spot trading fee
feeSpot := client.ComputeFee("spot", 1000.0, "Non-VIP", "taker")
// Result: 1.0 USDT (0.1%)

// Derivatives with leverage
margin := 100.0
leverage := 10.0
volume := margin * leverage // 1000
feeDeriv := client.ComputeFee("derivatives", volume, "VIP1", "maker")

🌍 Regional Endpoints

Region	Code	Endpoint
🌐 Global	`global`	`https://api.bybit.com`
🇳🇱 Netherlands	`nl`	`https://api.bybit.nl`
🇹🇷 Turkey	`tr`	`https://api.bybit-tr.com`
🇰🇿 Kazakhstan	`kz`	`https://api.bybit.kz`
🇬🇪 Georgia	`ge`	`https://api.bybitgeorgia.ge`
🇦🇪 UAE	`ae`	`https://api.bybit.ae`
🧪 Testnet	-	`https://api-testnet.bybit.com`

🔐 Authentication

Signature Generation

Bybit V5 API uses HMAC-SHA256 or RSA-SHA256 for request signing:

For GET requests:

signature_payload = timestamp + api_key + recv_window + queryString

For POST requests:

signature_payload = timestamp + api_key + recv_window + jsonBody

HMAC-SHA256: Returns lowercase hex
RSA-SHA256: Returns base64

Required Headers

X-BAPI-API-KEY: your_api_key
X-BAPI-TIMESTAMP: 1234567890000
X-BAPI-RECV-WINDOW: 5000
X-BAPI-SIGN: generated_signature
X-BAPI-SIGN-TYPE: 2 (for HMAC)
Content-Type: application/json (for POST)

📖 Official Documentation: https://bybit-exchange.github.io/docs/v5/guide

📖 Examples

See the examples/ directory for complete working examples:

basic_client.go - Basic client initialization and usage
market_data.go - Market data retrieval
order_management.go - Order placement and management
websocket_public.go - Public WebSocket streams
websocket_private.go - Private WebSocket streams

� Examples

🎓 Learn by Example

Comprehensive examples to get you started quickly

Explore the examples/ directory for complete, runnable examples:

Example	Description	Difficulty
🎯 `basic_client.go`	Client initialization and basic API calls	⭐ Beginner
📊 `market_data.go`	Fetching real-time market data	⭐ Beginner
💰 `order_management.go`	Placing and managing orders	⭐⭐ Intermediate
🌐 `websocket_public.go`	Public WebSocket streams	⭐⭐ Intermediate
🔐 `websocket_private.go`	Private WebSocket streams	⭐⭐⭐ Advanced

Run any example:

cd examples
go run basic_client.go

🤝 Contributing

💡 We Love Contributions!

Want to make Bybit Go SDK even better? We welcome contributions of all kinds!

🐛 Found a Bug?

Report it

💡 Have an Idea?

Suggest a feature

📝 Want to Contribute?

Submit a PR

Quick Contribution Guide:

🍴 Fork the repository
🌿 Create your feature branch: git checkout -b feature/AmazingFeature
✍️ Commit your changes: git commit -m 'Add some AmazingFeature'
📤 Push to the branch: git push origin feature/AmazingFeature
🎉 Open a Pull Request

📄 License

MIT License

Free to use, modify, and distribute

Copyright (c) 2026 Igor Sazonov

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

🌟 Show Your Support

If this project helped you, please consider giving it a ⭐ star!

📬 Connect With Us

Author: Igor Sazonov (tigusigalpa)
Email: sovletig@gmail.com
GitHub: @tigusigalpa

🔗 Useful Links

📚 Official Bybit API Docs • 🐛 Report Bug • 💡 Request Feature • 💬 Discussions

Made with ❤️ and ☕ for the crypto trading community

Happy Trading! 🚀📈

_{⚠️ Disclaimer: Trading cryptocurrencies carries risk. This SDK is provided as-is without warranty. Always test on testnet first and never invest more than you can afford to lose.}

Documentation ¶

Index ¶

type Client
- func NewClient(config ClientConfig) (*Client, error)
type ClientConfig
type PlaceOrderParams
type SlTpParams
type WebSocket
- func NewWebSocket(config WebSocketConfig) *WebSocket
type WebSocketConfig

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type Client ¶

type Client struct {
	// contains filtered or unexported fields
}

func NewClient ¶

func NewClient(config ClientConfig) (*Client, error)

func (*Client) AmendOrder ¶

func (c *Client) AmendOrder(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) BaseURI ¶

func (c *Client) BaseURI() string

func (*Client) CancelAllOrders ¶

func (c *Client) CancelAllOrders(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) CancelOrder ¶

func (c *Client) CancelOrder(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) ComputeFee ¶

func (c *Client) ComputeFee(tradeType string, volume float64, level, liquidity string) float64

func (*Client) CreateOrder ¶

func (c *Client) CreateOrder(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) Endpoint ¶

func (c *Client) Endpoint() string

func (*Client) GetHistoryOrders ¶

func (c *Client) GetHistoryOrders(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) GetOpenOrders ¶

func (c *Client) GetOpenOrders(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) GetPositions ¶

func (c *Client) GetPositions(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) GetServerTime ¶

func (c *Client) GetServerTime() (map[string]interface{}, error)

func (*Client) GetTickers ¶

func (c *Client) GetTickers(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) GetWalletBalance ¶

func (c *Client) GetWalletBalance(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) PlaceOrder ¶

func (c *Client) PlaceOrder(params PlaceOrderParams) (map[string]interface{}, error)

func (*Client) Request ¶

func (c *Client) Request(method, path string, params map[string]interface{}) (map[string]interface{}, error)

func (*Client) SetLeverage ¶

func (c *Client) SetLeverage(category, symbol string, leverage float64, side *string) (map[string]interface{}, error)

func (*Client) SetTradingStop ¶

func (c *Client) SetTradingStop(params map[string]interface{}) (map[string]interface{}, error)

func (*Client) SwitchPositionMode ¶

func (c *Client) SwitchPositionMode(params map[string]interface{}) (map[string]interface{}, error)

type ClientConfig ¶

type ClientConfig struct {
	APIKey        string
	APISecret     string
	Testnet       bool
	Region        string
	RecvWindow    int
	Signature     string
	RSAPrivateKey string
	HTTPClient    *http.Client
}

type PlaceOrderParams ¶

type PlaceOrderParams struct {
	Type      string
	Symbol    string
	Execution string
	Price     *float64
	Side      *string
	Leverage  *float64
	Size      float64
	SlTp      *SlTpParams
	Extra     map[string]interface{}
}

type SlTpParams ¶

type SlTpParams struct {
	Type       string
	TakeProfit *float64
	StopLoss   *float64
}

type WebSocket ¶

type WebSocket struct {
	// contains filtered or unexported fields
}

func NewWebSocket ¶

func NewWebSocket(config WebSocketConfig) *WebSocket

func (*WebSocket) Close ¶

func (ws *WebSocket) Close() error

func (*WebSocket) Connect ¶

func (ws *WebSocket) Connect() error

func (*WebSocket) GetSubscriptions ¶

func (ws *WebSocket) GetSubscriptions() []string

func (*WebSocket) IsConnected ¶

func (ws *WebSocket) IsConnected() bool

func (*WebSocket) Listen ¶

func (ws *WebSocket) Listen() error

func (*WebSocket) OnMessage ¶

func (ws *WebSocket) OnMessage(callback func(map[string]interface{}))

func (*WebSocket) Ping ¶

func (ws *WebSocket) Ping() error

func (*WebSocket) Send ¶

func (ws *WebSocket) Send(message map[string]interface{}) error

func (ws *WebSocket) Subscribe(topics []string) error

func (*WebSocket) SubscribeExecution ¶

func (ws *WebSocket) SubscribeExecution() error

func (*WebSocket) SubscribeKline ¶

func (ws *WebSocket) SubscribeKline(symbol, interval string) error

func (*WebSocket) SubscribeOrder ¶

func (ws *WebSocket) SubscribeOrder() error

func (*WebSocket) SubscribeOrderbook ¶

func (ws *WebSocket) SubscribeOrderbook(symbol string, depth int) error

func (*WebSocket) SubscribePosition ¶

func (ws *WebSocket) SubscribePosition() error

func (*WebSocket) SubscribeTicker ¶

func (ws *WebSocket) SubscribeTicker(symbol string) error

func (*WebSocket) SubscribeTrade ¶

func (ws *WebSocket) SubscribeTrade(symbol string) error

func (*WebSocket) SubscribeWallet ¶

func (ws *WebSocket) SubscribeWallet() error

func (*WebSocket) Unsubscribe ¶

func (ws *WebSocket) Unsubscribe(topics []string) error

type WebSocketConfig ¶

type WebSocketConfig struct {
	APIKey    string
	APISecret string
	Testnet   bool
	Region    string
	IsPrivate bool
}

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
examples

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL