OpenClaw 与 Go 应用集成主要有以下几种方法

openclaw openclaw官方 2026-04-09 1

使用 OpenClaw Go SDK

安装 SDK

go get github.com/openclaw/openclaw-go-sdk

基本使用示例

package main
import (
    "context"
    "fmt"
    "log"
    "github.com/openclaw/openclaw-go-sdk/clients"
    "github.com/openclaw/openclaw-go-sdk/models"
)
func main() {
    // 初始化客户端
    cfg := &clients.Config{
        APIKey:    "your-api-key",
        APISecret: "your-api-secret",
        BaseURL:   "https://api.openclaw.com/v1",
    }
    client := clients.NewClient(cfg)
    // 创建爬虫任务
    task := &models.Task{
        URL:       "https://example.com",
        Selectors: map[string]string{
            "title":   "h1",
            "content": ".article-content",
        },
        Settings: models.TaskSettings{
            JavaScript:   true,
            Proxy:        "auto",
            Timeout:      30,
        },
    }
    // 提交任务
    result, err := client.SubmitTask(context.Background(), task)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Task ID: %s\n", result.TaskID)
    // 获取结果
    taskResult, err := client.GetTaskResult(context.Background(), result.TaskID)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Extracted data: %v\n", taskResult.Data)
}

HTTP API 集成

RESTful API 调用

package main
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)
type TaskRequest struct {
    URL       string            `json:"url"`
    Selectors map[string]string `json:"selectors"`
    Settings  map[string]any    `json:"settings"`
}
func main() {
    apiKey := "your-api-key"
    url := "https://api.openclaw.com/v1/tasks"
    task := TaskRequest{
        URL: "https://example.com",
        Selectors: map[string]string{
            "title": "h1",
        },
        Settings: map[string]any{
            "javascript": true,
            "timeout":    30,
        },
    }
    body, _ := json.Marshal(task)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-API-Key", apiKey)
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    respBody, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(respBody))
}

Webhook 集成

配置 Webhook 接收器

package main
import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
)
type WebhookData struct {
    TaskID    string                 `json:"task_id"`
    Status    string                 `json:"status"`
    Data      map[string]interface{} `json:"data"`
    Timestamp string                 `json:"timestamp"`
}
func webhookHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != "POST" {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
    var data WebhookData
    if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    // 处理爬取结果
    log.Printf("Received webhook for task %s: %s", data.TaskID, data.Status)
    // 存储数据到数据库
    // processData(data.Data)
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "Webhook received")
}
func main() {
    http.HandleFunc("/webhook/openclaw", webhookHandler)
    log.Println("Starting webhook server on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

高级集成模式

并发任务处理

package main
import (
    "context"
    "sync"
    "time"
    "github.com/openclaw/openclaw-go-sdk/clients"
)
func batchCrawl(client *clients.Client, urls []string) []map[string]interface{} {
    var wg sync.WaitGroup
    results := make([]map[string]interface{}, len(urls))
    errCh := make(chan error, len(urls))
    for i, url := range urls {
        wg.Add(1)
        go func(idx int, u string) {
            defer wg.Done()
            task := &models.Task{
                URL: u,
                Selectors: map[string]string{
                    "title": "h1",
                },
            }
            result, err := client.SubmitTask(context.Background(), task)
            if err != nil {
                errCh <- err
                return
            }
            // 轮询获取结果
            for {
                taskResult, err := client.GetTaskResult(context.Background(), result.TaskID)
                if err != nil {
                    errCh <- err
                    return
                }
                if taskResult.Status == "completed" {
                    results[idx] = taskResult.Data
                    break
                }
                time.Sleep(2 * time.Second)
            }
        }(i, url)
    }
    wg.Wait()
    close(errCh)
    return results
}

Docker 容器集成

Docker Compose 配置

version: '3.8'
services:
  go-app:
    build: .
    environment:
      OPENCLAW_API_KEY: ${OPENCLAW_API_KEY}
      OPENCLAW_BASE_URL: https://api.openclaw.com/v1
    ports:
      - "8080:8080"
    depends_on:
      - openclaw-worker
    networks:
      - app-network
  openclaw-worker:
    image: openclaw/openclaw-worker:latest
    environment:
      REDIS_URL: redis://redis:6379
      BROKER_URL: amqp://rabbitmq:5672
    networks:
      - app-network
  redis:
    image: redis:alpine
    networks:
      - app-network
  rabbitmq:
    image: rabbitmq:management
    networks:
      - app-network
networks:
  app-network:
    driver: bridge

最佳实践建议

配置管理

// config/config.go
package config
import "os"
type OpenClawConfig struct {
    APIKey    string
    APISecret string
    BaseURL   string
    Timeout   int
}
func LoadConfig() *OpenClawConfig {
    return &OpenClawConfig{
        APIKey:    os.Getenv("OPENCLAW_API_KEY"),
        APISecret: os.Getenv("OPENCLAW_API_SECRET"),
        BaseURL:   os.Getenv("OPENCLAW_BASE_URL"),
        Timeout:   30,
    }
}

错误处理与重试

package main
import (
    "time"
    "github.com/avast/retry-go"
)
func submitTaskWithRetry(client *clients.Client, task *models.Task) (*models.TaskResult, error) {
    var result *models.TaskResult
    err := retry.Do(
        func() error {
            var err error
            result, err = client.SubmitTask(context.Background(), task)
            return err
        },
        retry.Attempts(3),
        retry.Delay(2*time.Second),
        retry.OnRetry(func(n uint, err error) {
            log.Printf("Retry %d: %v", n, err)
        }),
    )
    return result, err
}