API接入

币安API Go语言怎么调？net/http与go-binance代码

2026-04-15 · 24 分钟 · FlyVault 编辑组

币安 Go 语言 API 完整教程：标准库 crypto/hmac 签名、net/http 请求封装、go-binance 官方社区库、gorilla/websocket 实时订阅、goroutine 并发下单实战代码。

币安 Go 语言 API 接入兼具 极高性能 和 零依赖部署 两大优势，单二进制文件在 Linux 服务器运行，延迟比 Python / Node.js 低 30-50%。标准方案是：标准库 crypto/hmac 生成签名 + net/http 发送请求，或直接使用社区库 github.com/adshao/go-binance/v2。本文给出原生封装、SDK 使用、WebSocket 订阅、并发下单四个模块的完整代码。未注册币安的请先在 币安官网 完成 KYC，新用户可以 免费注册。

一、Go 语言 SDK 对比

库 路径 GitHub stars 特点
adshao/go-binance github.com/adshao/go-binance/v2 3.2k 社区首选，Spot + Futures 全支持
go-numb/go-binance github.com/go-numb/go-binance 50+ 轻量，侧重 WebSocket
原生 net/http 标准库 — 极致可控，零依赖

推荐：快速开发选 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,
            },
        },
    }
}

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("订单 %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, "，5s 后重试")
            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)

注意：币安 Spot 每 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: 需要。币安强制 24 小时断开所有 WS，gorilla/websocket 没有自动重连机制。参考第四节的 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 教程。

继续浏览

对币安使用还有疑问？回到分类页查找同主题的其它教程。

分类导航

相关教程

币安API怎么申请？密钥签名一般要怎么生成 2026-04-14 币安Spot API怎么用？从零到第一单的可运行代码 2026-04-14 币安Futures和Spot API有什么区别？端点参数权重对比 2026-04-14 币安API会被封IP吗？限频策略与权重计算详解 2026-04-14