バイナンスAPIをGo言語で呼び出す方法：net/httpとgo-binanceの実装例

バイナンス（Binance）のGo言語API接続は、極めて高いパフォーマンスとゼロ依存デプロイという2つの大きな利点を備えています。単一のバイナリファイルをLinuxサーバーで実行することで、PythonやNode.jsと比較して遅延を30〜50%削減できます。標準的なアプローチは、標準ライブラリの crypto/hmac で署名を生成し net/http でリクエストを送信するか、コミュニティライブラリの github.com/adshao/go-binance/v2 を直接使用することです。この記事では、ネイティブ実装、SDKの使用、WebSocket購読、並列注文の4つのモジュールの完全なコードを紹介します。バイナンスに未登録の方は、まず バイナンス公式サイト でKYC（本人確認）を完了させてください。新規ユーザーの方は 無料登録 も可能です。

一、Go言語SDKの比較

推奨：迅速な開発には adshao/go-binance を、カスタマイズやHFT（高頻度取引）シナリオにはネイティブの net/http を使用してください。

二、標準ライブラリ net/http による署名実装

1. プロジェクトの初期化

mkdir binance-go && cd binance-go
go mod init binance-go
go get github.com/joho/godotenv

.env ファイルの設定：

BINANCE_API_KEY=your_key
BINANCE_SECRET_KEY=your_secret

2. コア署名とリクエストの実装

client.go:

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "strconv"
    "time"
)

const BaseURL = "https://api.binance.com"

type Client struct {
    APIKey    string
    SecretKey string
    HTTPClient *http.Client
}

func NewClient() *Client {
    return &Client{
        APIKey:    os.Getenv("BINANCE_API_KEY"),
        SecretKey: os.Getenv("BINANCE_SECRET_KEY"),
        HTTPClient: &http.Client{
            Timeout: 10 * time.Second,
            Transport: &http.Transport{
                MaxIdleConns:        100,
                MaxIdleConnsPerHost: 100,
                IdleConnTimeout:     90 * time.Second,
            },
        },
    }
}

// HMAC-SHA256署名を生成
func (c *Client) sign(payload string) string {
    h := hmac.New(sha256.New, []byte(c.SecretKey))
    h.Write([]byte(payload))
    return hex.EncodeToString(h.Sum(nil))
}

func (c *Client) Request(method, path string, params url.Values, signed bool) ([]byte, error) {
    if params == nil {
        params = url.Values{}
    }
    if signed {
        params.Set("timestamp", strconv.FormatInt(time.Now().UnixMilli(), 10))
        params.Set("recvWindow", "5000")
        query := params.Encode()
        params.Set("signature", c.sign(query))
    }

    fullURL := BaseURL + path
    var req *http.Request
    var err error

    if method == "GET" || method == "DELETE" {
        fullURL = fullURL + "?" + params.Encode()
        req, err = http.NewRequest(method, fullURL, nil)
    } else {
        req, err = http.NewRequest(method, fullURL, nil)
        req.URL.RawQuery = params.Encode()
    }
    if err != nil {
        return nil, err
    }

    if signed {
        req.Header.Set("X-MBX-APIKEY", c.APIKey)
    }

    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }
    if resp.StatusCode >= 400 {
        return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
    }
    return body, nil
}

type Balance struct {
    Asset  string `json:"asset"`
    Free   string `json:"free"`
    Locked string `json:"locked"`
}

type Account struct {
    CanTrade bool      `json:"canTrade"`
    Balances []Balance `json:"balances"`
}

// アカウント情報を取得
func (c *Client) GetAccount() (*Account, error) {
    body, err := c.Request("GET", "/api/v3/account", nil, true)
    if err != nil {
        return nil, err
    }
    var acc Account
    if err := json.Unmarshal(body, &acc); err != nil {
        return nil, err
    }
    return &acc, nil
}

type Ticker struct {
    Symbol string `json:"symbol"`
    Price  string `json:"price"`
}

// 最新価格を取得
func (c *Client) GetPrice(symbol string) (float64, error) {
    params := url.Values{}
    params.Set("symbol", symbol)
    body, err := c.Request("GET", "/api/v3/ticker/price", params, false)
    if err != nil {
        return 0, err
    }
    var t Ticker
    if err := json.Unmarshal(body, &t); err != nil {
        return 0, err
    }
    return strconv.ParseFloat(t.Price, 64)
}

type Order struct {
    Symbol       string `json:"symbol"`
    OrderID      int64  `json:"orderId"`
    ClientOrderID string `json:"clientOrderId"`
    Status       string `json:"status"`
    ExecutedQty  string `json:"executedQty"`
}

// 指値注文を発注
func (c *Client) PlaceLimitOrder(symbol, side, quantity, price string) (*Order, error) {
    params := url.Values{}
    params.Set("symbol", symbol)
    params.Set("side", side)
    params.Set("type", "LIMIT")
    params.Set("timeInForce", "GTC")
    params.Set("quantity", quantity)
    params.Set("price", price)

    body, err := c.Request("POST", "/api/v3/order", params, true)
    if err != nil {
        return nil, err
    }
    var o Order
    if err := json.Unmarshal(body, &o); err != nil {
        return nil, err
    }
    return &o, nil
}

3. メインプログラム

main.go:

package main

import (
    "fmt"
    "log"
    "strconv"

    "github.com/joho/godotenv"
)

func main() {
    if err := godotenv.Load(); err != nil {
        log.Println(".envファイルが見つかりません。環境変数を使用します。")
    }

    c := NewClient()

    // アカウント情報の照会
    account, err := c.GetAccount()
    if err != nil {
        log.Fatalln("アカウント情報の取得に失敗しました:", err)
    }
    fmt.Printf("取引可能: %v\n", account.CanTrade)
    for _, b := range account.Balances {
        free, _ := strconv.ParseFloat(b.Free, 64)
        if free > 0 {
            fmt.Printf("  %s: %s (ロック中 %s)\n", b.Asset, b.Free, b.Locked)
        }
    }

    // 価格の照会
    price, _ := c.GetPrice("BTCUSDT")
    fmt.Printf("BTC 最新価格: %.2f\n", price)

    // 指値注文（市場価格の-10%に設定）
    testPrice := fmt.Sprintf("%.2f", price*0.9)
    order, err := c.PlaceLimitOrder("BTCUSDT", "BUY", "0.001", testPrice)
    if err != nil {
        log.Fatalln("注文に失敗しました:", err)
    }
    fmt.Printf("注文 %d が作成されました。ステータス: %s\n", order.OrderID, order.Status)
}

実行コマンド：

go run *.go

三、go-binance コミュニティライブラリ

1. インストール

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

2. 現物（Spot）の実装例

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/adshao/go-binance/v2"
)

func main() {
    client := binance.NewClient(
        os.Getenv("BINANCE_API_KEY"),
        os.Getenv("BINANCE_SECRET_KEY"),
    )
    ctx := context.Background()

    // 残高の照会
    account, err := client.NewGetAccountService().Do(ctx)
    if err != nil {
        log.Fatal(err)
    }
    for _, b := range account.Balances {
        fmt.Printf("%s: %s\n", b.Asset, b.Free)
    }

    // 価格の照会
    prices, err := client.NewListPricesService().Symbol("BTCUSDT").Do(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(prices[0].Price)

    // 指値買い注文
    order, err := client.NewCreateOrderService().
        Symbol("BTCUSDT").
        Side(binance.SideTypeBuy).
        Type(binance.OrderTypeLimit).
        TimeInForce(binance.TimeInForceTypeGTC).
        Quantity("0.001").
        Price("60000.00").
        Do(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("注文 ID: %d\n", order.OrderID)

    // K線（ローソク足）
    klines, _ := client.NewKlinesService().
        Symbol("BTCUSDT").
        Interval("1h").
        Limit(100).
        Do(ctx)
    fmt.Printf("%d 本の K線を取得しました\n", len(klines))
}

3. 先物（Futures）の実装例

futuresClient := binance.NewFuturesClient(apiKey, secret)

// レバレッジの設定
_, err := futuresClient.NewChangeLeverageService().
    Symbol("BTCUSDT").Leverage(10).Do(ctx)

// ロングポジションのオープン
futuresOrder, err := futuresClient.NewCreateOrderService().
    Symbol("BTCUSDT").
    Side(binance.SideTypeBuy).
    Type(binance.OrderTypeLimit).
    TimeInForce(binance.TimeInForceTypeGTC).
    Quantity("0.01").
    Price("60000").
    PositionSide(binance.PositionSideTypeLong).
    Do(ctx)

// ポジションの照会
positions, _ := futuresClient.NewGetPositionRiskService().Do(ctx)
for _, p := range positions {
    if p.PositionAmt != "0" {
        fmt.Printf("%s ポジション %s @ %s\n", p.Symbol, p.PositionAmt, p.EntryPrice)
    }
}

四、WebSocket 購読（gorilla/websocket）

go get github.com/gorilla/websocket

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "time"

    "github.com/gorilla/websocket"
)

type TickerEvent struct {
    EventType string `json:"e"`
    EventTime int64  `json:"E"`
    Symbol    string `json:"s"`
    Close     string `json:"c"`
    Change    string `json:"P"`
    Volume    string `json:"v"`
}

func main() {
    url := "wss://stream.binance.com:9443/stream?streams=btcusdt@ticker/ethusdt@ticker"

    for {
        conn, _, err := websocket.DefaultDialer.Dial(url, nil)
        if err != nil {
            log.Println("接続失敗:", err, "。5秒後に再試行します")
            time.Sleep(5 * time.Second)
            continue
        }
        log.Println("WS 接続完了")

        // ハートビート用の goroutine
        stop := make(chan struct{})
        go func() {
            ticker := time.NewTicker(3 * time.Minute)
            defer ticker.Stop()
            for {
                select {
                case <-ticker.C:
                    conn.WriteMessage(websocket.PingMessage, nil)
                case <-stop:
                    return
                }
            }
        }()

        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("読み取りエラー:", err)
                close(stop)
                conn.Close()
                break
            }
            var combined struct {
                Stream string      `json:"stream"`
                Data   TickerEvent `json:"data"`
            }
            if err := json.Unmarshal(message, &combined); err != nil {
                continue
            }
            fmt.Printf("%s: %s (24h 変化率 %s%%)\n",
                combined.Data.Symbol,
                combined.Data.Close,
                combined.Data.Change)
        }
    }
}

五、goroutine による並列注文

Go の並行処理モデルは、複数の注文を同時に出すのに適しています：

func placeParallel(c *Client, orders []OrderSpec) []error {
    errs := make([]error, len(orders))
    done := make(chan int, len(orders))

    for i, spec := range orders {
        go func(idx int, s OrderSpec) {
            _, err := c.PlaceLimitOrder(s.Symbol, s.Side, s.Quantity, s.Price)
            errs[idx] = err
            done <- idx
        }(i, spec)
    }

    for range orders {
        <-done
    }
    return errs
}

type OrderSpec struct {
    Symbol   string
    Side     string
    Quantity string
    Price    string
}

// 使用例
specs := []OrderSpec{
    {"BTCUSDT", "BUY", "0.001", "60000"},
    {"ETHUSDT", "BUY", "0.01", "3000"},
    {"BNBUSDT", "BUY", "0.1", "500"},
}
errors := placeParallel(client, specs)

注意：バイナンスの現物は10秒間に100注文の制限があります。並列数は50を超えないようにしてください。そうしないとレート制限に抵触しやすくなります。

六、よくある質問 FAQ

Q1: Go でコンパイルしたバイナリのサイズは？ 依存関係はありますか？

A: 完全なバイナンス API 機能と WebSocket を備えたプログラムで、コンパイル後は約 8〜15MB です。Linux や Docker で直接実行でき、実行時の依存関係は一切ありません（Node.js の node_modules が数百 MB になるのと対照的です）。

Q2: go-binance とネイティブの net/http でパフォーマンスに差はありますか？

A: 差はほとんどありません。go-binance は薄いラッパーに過ぎないからです。単一の REST 呼び出しで 5〜8ms、1000 回の並行負荷テストでの遅延 p99 は 30ms 未満です。Python の 80〜100ms と比較すると、Go には 10 倍以上の優位性があります。

Q3: バイナンスから返されるエラーをどのように適切に処理すべきですか？

A: バイナンスは {"code": -1021, "msg": "..."} という形式でエラーを返します。以下のように BinanceError 型を定義して統一的に処理することをお勧めします。

type BinanceError struct {
    Code int    `json:"code"`
    Msg  string `json:"msg"`
}

func (e *BinanceError) Error() string {
    return fmt.Sprintf("Binance %d: %s", e.Code, e.Msg)
}

Q4: Go の WebSocket は 24 時間ごとの切断を自分で処理する必要がありますか？

A: はい、必要です。バイナンスはすべての WS 接続を 24 時間で強制的に切断します。gorilla/websocket には自動再接続機能がないため、第4セクションの for ループ + Dial パターンを使用してシームレスな再接続を実装してください。

Q5: Docker でデプロイするには？

A: マルチステージビルドを使用すれば、最終的なイメージはわずか 20MB 程度になります：

FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY . .
RUN CGO_ENABLED=0 go build -o bot

FROM alpine:3.19
RUN apk add --no-cache ca-certificates tzdata
COPY --from=builder /app/bot /bot
ENTRYPOINT ["/bot"]

Go の実装案を確認したら、カテゴリナビ に戻って「API連携」カテゴリの他の言語 SDK ガイドをチェックしましょう。