Go SDK

import (
	"github.com/anthropics/anthropic-sdk-go" // imported as anthropic
)

go get github.com/anthropics/anthropic-sdk-go

package main

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/option"
)

func main() {
	client := anthropic.NewClient(
		option.WithAPIKey("my-anthropic-api-key"), // defaults to os.LookupEnv("ANTHROPIC_API_KEY")
	)
	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("What is a quaternion?")),
		},
		Model: anthropic.ModelClaudeOpus5,
	})
	if err != nil {
		panic(err.Error())
	}
	for _, block := range message.Content {
		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
			fmt.Println(textBlock.Text)
		}
	}
}

p := anthropic.ExampleParams{
	ID:   "id_xxx",                // required property
	Name: anthropic.String("..."), // optional property

	Point: anthropic.Point{
		X: 0,                // required field will serialize as 0
		Y: anthropic.Int(1), // optional field will serialize as 1
		// ... 생략된 비필수 필드는 직렬화되지 않습니다
	},

	Origin: anthropic.Origin{}, // the zero value of [Origin] is considered omitted
}

p.Name = param.Null[string]()       // 'null' instead of string
p.Point = param.NullStruct[Point]() // 'null' instead of struct

param.IsNull(p.Name)  // true
param.IsNull(p.Point) // true

// API가 특정 타입을 지정하지만
// 다른 것을 보내고 싶은 경우 [SetExtraFields]를 사용하세요:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// 객체 대신 숫자를 전송
custom := param.Override[anthropic.FooParams](12)

// 하나의 필드만 0이 아닌 값을 가질 수 있으며, 필드가 설정되었는지 확인하려면 param.IsOmitted()를 사용하세요
type AnimalUnionParam struct {
	OfCat *Cat `json:",omitzero,inline"`
	OfDog *Dog `json:",omitzero,inline"`
}

animal := AnimalUnionParam{
	OfCat: &Cat{
		Name: "Whiskers",
		Owner: PersonParam{
			Address: AddressParam{Street: "3333 Coyote Hill Rd", ZipCode: 0},
		},
	},
}

// 필드 변경하기
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}

// params를 직렬화합니다 (예: 저장 또는 전달용)
b, err := json.Marshal(original)
if err != nil {
	panic(err)
}

// 나중에 저장된 JSON에서 params를 재구성합니다
var params anthropic.MessageNewParams
if err := params.UnmarshalJSON(b); err != nil {
	panic(err)
}
param.SetJSON(b, &params)

// params.Model 및 기타 스칼라 필드는 UnmarshalJSON에 의해 채워집니다.
// params.Tools[0].OfBashTool20250124는 nil이지만 (유니온 제한 사항),
// 원시 JSON은 보존됩니다. params가 API 호출을 위해
// 다시 마샬링될 때 도구는 올바르게 직렬화됩니다.
b2, _ := json.Marshal(params)
fmt.Println(string(b) == string(b2)) // true

type Animal struct {
	Name   string `json:"name,nullable"`
	Owners int    `json:"owners"`
	Age    int    `json:"age"`
	JSON   struct {
		Name        respjson.Field
		Owners      respjson.Field
		Age         respjson.Field
		ExtraFields map[string]respjson.Field
	} `json:"-"`
}

raw := `{"owners": 1, "name": null}`

var res Animal
json.Unmarshal([]byte(raw), &res)

// 일반 필드 접근

res.Owners // 1
res.Name   // ""
res.Age    // 0

// 선택적 필드 확인

res.JSON.Owners.Valid() // true
res.JSON.Name.Valid()   // false
res.JSON.Age.Valid()    // false

// 원시 JSON 값

res.JSON.Owners.Raw()                  // "1"
res.JSON.Name.Raw() == "null"          // true
res.JSON.Name.Raw() == respjson.Null   // true
res.JSON.Age.Raw() == ""               // true
res.JSON.Age.Raw() == respjson.Omitted // true

body := res.JSON.ExtraFields["my_unexpected_field"].Raw()

type AnimalUnion struct {
	// [Dog], [Cat] 변형에서
	Owner Person `json:"owner"`
	// [Dog] 변형에서
	DogBreed string `json:"dog_breed"`
	// [Cat] 변형에서
	CatBreed string `json:"cat_breed"`
	// ...

	JSON struct {
		Owner respjson.Field
		// ...
	} `json:"-"`
}

// animal 변형인 경우
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// 변형에 따라 분기
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}

_, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	MaxTokens: 1024,
	Messages: []anthropic.MessageParam{{
		Content: []anthropic.ContentBlockParamUnion{{
			OfText: &anthropic.TextBlockParam{
				Text: "What is a quaternion?",
			},
		}},
		Role: anthropic.MessageParamRoleUser,
	}},
	Model: anthropic.ModelClaudeOpus5,
})
if err != nil {
	var apierr *anthropic.Error
	if errors.As(err, &apierr) {
		println("Request ID:", apierr.RequestID)
		println(string(apierr.DumpRequest(true)))  // Prints the serialized HTTP request
		println(string(apierr.DumpResponse(true))) // Prints the serialized HTTP response
	}
	panic(err.Error()) // POST "/v1/messages": 400 Bad Request (Request-ID: req_xxx) { ... }
}

// 모든 요청에 대한 기본값 구성:
client := anthropic.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// 요청별 재정의:
// ...
	client.Messages.New(
		context.TODO(),
		anthropic.MessageNewParams{
			MaxTokens: 1024,
			Messages: []anthropic.MessageParam{{
				Content: []anthropic.ContentBlockParamUnion{{
					OfText: &anthropic.TextBlockParam{
						Text: "What is a quaternion?",
					},
				}},
				Role: anthropic.MessageParamRoleUser,
			}},
			Model: anthropic.ModelClaudeOpus5,
		},
		option.WithMaxRetries(5),
	)

// 모든 재시도를 포함한 요청의 타임아웃을 설정합니다.
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()
// ...
	client.Messages.New(
		ctx,
		anthropic.MessageNewParams{
			MaxTokens: 1024,
			Messages: []anthropic.MessageParam{{
				Content: []anthropic.ContentBlockParamUnion{{
					OfText: &anthropic.TextBlockParam{
						Text: "What is a quaternion?",
					},
				}},
				Role: anthropic.MessageParamRoleUser,
			}},
			Model: anthropic.ModelClaudeOpus5,
		},
		// 재시도별 타임아웃을 설정합니다
		option.WithRequestTimeout(20*time.Second),
	)

// 파일 시스템의 파일
file, err := os.Open("/path/to/file.json")
anthropic.BetaFileUploadParams{
	File: anthropic.File(file, "custom-name.json", "application/json"),
}

// 문자열로부터의 파일
anthropic.BetaFileUploadParams{
	File: anthropic.File(strings.NewReader("my file contents"), "custom-name.json", "application/json"),
}

iter := client.Messages.Batches.ListAutoPaging(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
// 필요에 따라 자동으로 더 많은 페이지를 가져옵니다.
for iter.Next() {
	messageBatch := iter.Current()
	fmt.Printf("%+v\n", messageBatch)
}
if err := iter.Err(); err != nil {
	panic(err.Error())
}

page, err := client.Messages.Batches.List(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
for page != nil {
	for _, batch := range page.Data {
		fmt.Printf("%+v\n", batch)
	}
	page, err = page.GetNextPage()
}
if err != nil {
	panic(err.Error())
}

client := anthropic.NewClient(
	// 클라이언트가 보내는 모든 요청에 헤더를 추가합니다
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Messages.New(context.TODO(), // ...,
	// 헤더를 재정의합니다
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// sjson 구문을 사용하여 요청 본문에 문서화되지 않은 필드를 추가합니다
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

// HTTP 응답을 저장할 변수를 생성합니다
var response *http.Response
message, err := client.Messages.New(
	context.TODO(),
	anthropic.MessageNewParams{
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{{
			Content: []anthropic.ContentBlockParamUnion{{
				OfText: &anthropic.TextBlockParam{
					Text: "What is a quaternion?",
				},
			}},
			Role: anthropic.MessageParamRoleUser,
		}},
		Model: anthropic.ModelClaudeOpus5,
	},
	option.WithResponseInto(&response),
)
if err != nil {
	// 오류 처리
}
fmt.Printf("%+v\n", message)

fmt.Printf("Status Code: %d\n", response.StatusCode)
fmt.Printf("Headers: %+#v\n", response.Header)

var (
	// params는 io.Reader, []byte, encoding/json 직렬화 가능 객체,
	// 또는 이 라이브러리에 정의된 "...Params" 구조체가 될 수 있습니다.
	params map[string]any

	// result는 []byte, *http.Response, encoding/json 역직렬화 가능 객체,
	// 또는 이 라이브러리에 정의된 모델이 될 수 있습니다.
	result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
	// ...
}

params := FooNewParams{
	ID: "id_xxxx",
	Data: FooNewParamsData{
		FirstName: anthropic.String("John"),
	},
}
client.Foo.New(context.Background(), params, option.WithJSONSet("data.last_name", "Doe"))