---
title: Go SDK
url: https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/sdks/go
description: Instale e configure o Anthropic Go SDK com cancelamento baseado em contexto e opções funcionais
---

A biblioteca Anthropic Go fornece acesso conveniente à Claude API a partir de aplicações escritas em Go.

<Info>
  Para documentação de recursos da API com exemplos de código, consulte a [referência da API](https://platform.claude.com/docs/pt-BR/api/overview). Esta página cobre recursos e configurações específicos do SDK Go.
</Info>

## Instalação

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

Instale com `go get`:

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

## Requisitos

Esta biblioteca requer Go 1.24+.

## Uso

```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_5,
	})
	if err != nil {
		panic(err.Error())
	}
	for _, block := range message.Content {
		if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
			fmt.Println(textBlock.Text)
		}
	}
}
```

Para opções de autenticação, incluindo Workload Identity Federation, consulte [Autenticação](https://platform.claude.com/docs/pt-BR/manage-claude/authentication). Se sua chave de API for uma [chave pessoal ou de conta de serviço](https://platform.claude.com/docs/pt-BR/manage-claude/authentication#key-types) com acesso a vários workspaces, defina o ID do workspace no cabeçalho de requisição `anthropic-workspace-id`; [Selecionar um workspace](https://platform.claude.com/docs/pt-BR/manage-claude/authentication#select-a-workspace) mostra a opção por requisição para este SDK.

<AccordionGroup>
  <Accordion title="Conversas">
    ```go
    messages := []anthropic.MessageParam{
    	anthropic.NewUserMessage(anthropic.NewTextBlock("What is my first name?")),
    }

    message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
    	Model:     anthropic.ModelClaudeOpus5_5,
    	Messages:  messages,
    	MaxTokens: 1024,
    })
    if err != nil {
    	panic(err)
    }

    fmt.Printf("%+v\n", message.Content)

    messages = append(messages, message.ToParam())
    messages = append(messages, anthropic.NewUserMessage(
    	anthropic.NewTextBlock("My full name is John Doe"),
    ))

    message, err = client.Messages.New(context.TODO(), anthropic.MessageNewParams{
    	Model:     anthropic.ModelClaudeOpus5_5,
    	Messages:  messages,
    	MaxTokens: 1024,
    })
    if err != nil {
    	panic(err)
    }

    fmt.Printf("%+v\n", message.Content)
    ```
  </Accordion>

  <Accordion title="Prompts do sistema">
    ```go
    message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
    	Model:     anthropic.ModelClaudeOpus5_5,
    	MaxTokens: 1024,
    	System: []anthropic.TextBlockParam{
    		{Text: "Be very serious at all times."},
    	},
    	Messages: messages,
    })
    if err != nil {
    	panic(err)
    }
    fmt.Printf("%+v\n", message.Content)
    ```
  </Accordion>

  <Accordion title="Streaming">
    ```go
    content := "What is a quaternion?"

    stream := client.Messages.NewStreaming(context.TODO(), anthropic.MessageNewParams{
    	Model:     anthropic.ModelClaudeOpus5_5,
    	MaxTokens: 1024,
    	Messages: []anthropic.MessageParam{
    		anthropic.NewUserMessage(anthropic.NewTextBlock(content)),
    	},
    })

    message := anthropic.Message{}
    for stream.Next() {
    	event := stream.Current()
    	err := message.Accumulate(event)
    	if err != nil {
    		panic(err)
    	}

    	switch eventVariant := event.AsAny().(type) {
    	case anthropic.ContentBlockDeltaEvent:
    		switch deltaVariant := eventVariant.Delta.AsAny().(type) {
    		case anthropic.TextDelta:
    			print(deltaVariant.Text)
    		}

    	}
    }

    if stream.Err() != nil {
    	panic(stream.Err())
    }
    ```
  </Accordion>

  <Accordion title="Chamada de ferramentas">
    ```go
    messages := []anthropic.MessageParam{
    	anthropic.NewUserMessage(anthropic.NewTextBlock(content)),
    }

    toolParams := []anthropic.ToolParam{
    	{
    		Name:        "get_coordinates",
    		Description: anthropic.String("Accepts a place as an address, then returns the latitude and longitude coordinates."),
    		InputSchema: GetCoordinatesInputSchema,
    	},
    }
    tools := make([]anthropic.ToolUnionParam, len(toolParams))
    for i, toolParam := range toolParams {
    	tools[i] = anthropic.ToolUnionParam{OfTool: &toolParam}
    }

    for {
    	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
    		Model:     anthropic.ModelClaudeOpus5_5,
    		MaxTokens: 1024,
    		Messages:  messages,
    		Tools:     tools,
    	})

    	if err != nil {
    		panic(err)
    	}

    	print(color("[assistant]: "))
    	for _, block := range message.Content {
    		switch block := block.AsAny().(type) {
    		case anthropic.TextBlock:
    			println(block.Text)
    			println()
    		case anthropic.ToolUseBlock:
    			inputJSON, _ := json.Marshal(block.Input)
    			println(block.Name + ": " + string(inputJSON))
    			println()
    		}
    	}

    	messages = append(messages, message.ToParam())
    	toolResults := []anthropic.ContentBlockParamUnion{}

    	for _, block := range message.Content {
    		switch variant := block.AsAny().(type) {
    		case anthropic.ToolUseBlock:
    			print(color("[user (" + block.Name + ")]: "))

    			var response interface{}
    			switch block.Name {
    			case "get_coordinates":
    				var input struct {
    					Location string `json:"location"`
    				}

    				err := json.Unmarshal([]byte(variant.JSON.Input.Raw()), &input)
    				if err != nil {
    					panic(err)
    				}

    				response = GetCoordinates(input.Location)
    			}

    			b, err := json.Marshal(response)
    			if err != nil {
    				panic(err)
    			}

    			println(string(b))

    			toolResults = append(toolResults, anthropic.NewToolResultBlock(block.ID, string(b), false))
    		}

    	}
    	if len(toolResults) == 0 {
    		break
    	}
    	messages = append(messages, anthropic.NewUserMessage(toolResults...))
    }
    ```
  </Accordion>
</AccordionGroup>

## Campos de requisição

A biblioteca da Anthropic usa a semântica [`omitzero`](https://tip.golang.org/doc/go1.24#encodingjsonpkgencodingjson) do lançamento `encoding/json` do Go 1.24+ para campos de requisição.

Campos primitivos obrigatórios (como `int64` ou `string`) apresentam a tag `` `json:"...,required"` ``. Esses campos são sempre serializados, mesmo seus valores zero.

Tipos primitivos opcionais são encapsulados em um `param.Opt[T]`. Esses campos podem ser definidos com os construtores fornecidos, como `anthropic.String(string)` ou `anthropic.Int(int64)`.

Qualquer `param.Opt[T]`, map, slice, struct ou enum de string usa a tag `` `json:"...,omitzero"` ``. Seu valor zero é considerado omitido.

A função `param.IsOmitted(any)` pode confirmar a presença de qualquer campo `omitzero`.

```go
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
		// ... campos não obrigatórios omitidos não serão serializados
	},

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

Para enviar `null` em vez de um `param.Opt[T]`, use `param.Null[T]()`. Para enviar `null` em vez de uma struct `T`, use `param.NullStruct[T]()`.

```go
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
```

As structs de requisição contêm um método `.SetExtraFields(map[string]any)` que pode enviar campos não conformes no corpo da requisição. Campos extras sobrescrevem quaisquer campos da struct com uma chave correspondente.

<Warning>
  Por razões de segurança, use `SetExtraFields` apenas com dados confiáveis.
</Warning>

Para enviar um valor personalizado em vez de uma struct, use a função genérica `param.Override` (por exemplo, `param.Override[anthropic.FooParams](12)`).

```go
// Nos casos em que a API especifica um determinado tipo,
// mas você quer enviar outra coisa, use [SetExtraFields]:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// Envia um número em vez de um objeto
custom := param.Override[anthropic.FooParams](12)
```

### Uniões de requisição

Uniões são representadas como uma struct com campos prefixados por "Of" para cada uma de suas variantes. Apenas um campo pode ser diferente de zero. O campo diferente de zero será serializado.

Subpropriedades da união podem ser acessadas através de métodos na struct da união. Esses métodos retornam um ponteiro mutável para os dados subjacentes, se presentes.

```go
// Apenas um campo pode ser diferente de zero, use param.IsOmitted() para verificar se um campo está definido
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},
		},
	},
}

// Alterando um campo
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}
```

### Desserializando params

<Note>
  `param.SetJSON` requer SDK v1.20.0 ou posterior.
</Note>

Tipos Param (tipos terminando em `Param`, como `MessageNewParams` ou `ToolUnionParam`) são projetados apenas para requisições de saída. Eles são serializados corretamente para JSON, mas não suportam totalmente a desserialização de ida e volta. Se você desserializar JSON bruto em uma struct param, campos de união tipados como `OfBashTool20250124` serão nil mesmo quando o JSON subjacente for válido.

Se você precisar reconstruir params a partir de JSON bruto (por exemplo, de um banco de dados, middleware ou uma requisição anterior), chame `UnmarshalJSON` para preencher campos não-união, depois use `param.SetJSON` para anexar os bytes brutos para re-serialização correta:

```go
// Serializa os params (por exemplo, para armazenamento ou encaminhamento)
b, err := json.Marshal(original)
if err != nil {
	panic(err)
}

// Depois, reconstrói os params a partir do JSON armazenado
var params anthropic.MessageNewParams
if err := params.UnmarshalJSON(b); err != nil {
	panic(err)
}
param.SetJSON(b, &params)

// params.Model e outros campos escalares são preenchidos por UnmarshalJSON.
// params.Tools[0].OfBashTool20250124 é nil (a limitação da union),
// mas o JSON bruto é preservado. Quando os params são serializados novamente
// para a chamada de API, as ferramentas são serializadas corretamente.
b2, _ := json.Marshal(params)
fmt.Println(string(b) == string(b2)) // true
```

Para este caso de uso, `param.SetJSON` (disponível desde v1.20.0) é preferível ao mais geral `param.Override[T](any)` porque não requer especificar o parâmetro de tipo e torna a intenção de ida e volta explícita.

## Objetos de resposta

Todos os campos em structs de resposta são tipos de valor comuns (não ponteiros ou wrappers). As structs de resposta também incluem um campo especial `JSON` contendo metadados sobre cada propriedade.

```go
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:"-"`
}
```

Para lidar com dados opcionais, use o método `.Valid()` no campo JSON. `.Valid()` retorna true quando o campo está presente, não é `null` e foi desserializado com sucesso.

Se `.Valid()` for false, o campo correspondente será seu valor zero.

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

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

// Acessando campos regulares

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

// Verificações de campos opcionais

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

// Valores JSON brutos

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
```

Essas structs `.JSON` também incluem um map `ExtraFields` contendo quaisquer propriedades na resposta JSON que não foram especificadas na struct. Isso pode ser útil para recursos da API ainda não presentes no SDK.

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

### Uniões de resposta

Em respostas, uniões são representadas por uma struct achatada contendo todos os campos possíveis de cada uma das variantes de objeto. Para convertê-la em uma variante use o método `.AsFooVariant()` ou o método `.AsAny()` se presente.

Se uma união de valor de resposta contiver valores primitivos, campos primitivos estarão ao lado das propriedades, mas prefixados com `Of` e apresentarão a tag `json:"...,inline"`.

```go
type AnimalUnion struct {
	// Das variantes [Dog], [Cat]
	Owner Person `json:"owner"`
	// Da variante [Dog]
	DogBreed string `json:"dog_breed"`
	// Da variante [Cat]
	CatBreed string `json:"cat_breed"`
	// ...

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

// Se variante animal
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// Alterna a variante
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}
```

## Tratamento de erros

Quando a API retorna um código de status de não-sucesso, o SDK retorna um erro com o tipo `*anthropic.Error`. Isso contém os valores `StatusCode`, `*http.Request` e `*http.Response` da requisição, junto com o JSON do corpo do erro (muito parecido com outros objetos de resposta no SDK). O erro também inclui o `RequestID` dos cabeçalhos da resposta, que é útil para solução de problemas com o suporte da Anthropic.

Para lidar com erros, use o padrão `errors.As`:

```go
_, 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_5,
})
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) { ... }
}
```

Quando outros erros ocorrem, eles são retornados sem encapsulamento; por exemplo, se o transporte HTTP falhar, você pode receber `*url.Error` encapsulando `*net.OpError`.

## Novas tentativas

Certos erros serão automaticamente repetidos 2 vezes por padrão, com um curto backoff exponencial. O SDK repete por padrão todos os erros de conexão, 408 Request Timeout, 409 Conflict, 429 Rate Limit e erros internos >=500.

Você pode usar a opção `WithMaxRetries` para configurar ou desabilitar isso:

```go
// Configure o padrão para todas as requisições:
client := anthropic.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Substitua por requisição:
// ...
	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_5,
		},
		option.WithMaxRetries(5),
	)
```

## Timeouts

Requisições Messages sem streaming expiram após 10 minutos por padrão; outras requisições não têm timeout padrão. Use context para configurar um timeout para o ciclo de vida de uma requisição.

Observe que se uma requisição for [repetida](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/sdks/go#retries), o timeout do context não recomeça. Para definir um timeout por tentativa, use `option.WithRequestTimeout()`.

```go
// Isso define o timeout da requisição, incluindo todas as novas tentativas.
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_5,
		},
		// Isso define o timeout de cada nova tentativa
		option.WithRequestTimeout(20*time.Second),
	)
```

## Requisições longas

<Warning>
  Considere usar a API Messages com streaming para requisições de execução mais longa.
</Warning>

Evite definir um valor grande de `MaxTokens` sem usar streaming, pois algumas redes podem descartar conexões ociosas após um certo período de tempo, o que pode fazer com que a requisição falhe ou [expire](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/sdks/go#timeouts) sem receber uma resposta da Anthropic.

Este SDK também retornará um erro se uma requisição sem streaming for esperada para durar mais de aproximadamente 10 minutos. Chamar `.Messages.NewStreaming()` ou [definir um timeout personalizado](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/sdks/go#timeouts) desabilita esse erro.

## Uploads de arquivos

Parâmetros de requisição que correspondem a uploads de arquivos em requisições multipart são tipados como `io.Reader`. O conteúdo do `io.Reader` será por padrão enviado como uma parte de formulário multipart com o nome de arquivo `anonymous_file` e content-type `application/octet-stream`, portanto a abordagem recomendada é especificar um content-type personalizado com o helper `anthropic.File(reader io.Reader, filename string, contentType string)`, que encapsula qualquer `io.Reader` com o nome de arquivo e content-type apropriados.

```go
// Um arquivo do sistema de arquivos
file, err := os.Open("/path/to/file.json")
anthropic.FileUploadParams{
	File: anthropic.File(file, "custom-name.json", "application/json"),
}

// Um arquivo a partir de uma string
anthropic.FileUploadParams{
	File: anthropic.File(strings.NewReader("my file contents"), "custom-name.json", "application/json"),
}
```

O nome do arquivo e o content-type também podem ser personalizados implementando `Name() string` ou `ContentType() string` no tipo de tempo de execução do `io.Reader`. Observe que `os.File` implementa `Name() string`, então um arquivo retornado por `os.Open` será enviado com o nome do arquivo em disco.

## Paginação

Esta biblioteca fornece algumas conveniências para trabalhar com endpoints de lista paginados.

Você pode usar métodos `.ListAutoPaging()` para iterar através de itens em todas as páginas:

```go
iter := client.Messages.Batches.ListAutoPaging(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
// Busca automaticamente mais páginas conforme necessário.
for iter.Next() {
	messageBatch := iter.Current()
	fmt.Println(messageBatch.ID)
}
if err := iter.Err(); err != nil {
	panic(err.Error())
}
```

Ou você pode usar métodos simples `.List()` para buscar uma única página e receber um objeto de resposta padrão com métodos auxiliares adicionais como `.GetNextPage()`:

```go
page, err := client.Messages.Batches.List(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
for page != nil {
	for _, batch := range page.Data {
		fmt.Println(batch.ID)
	}
	page, err = page.GetNextPage()
}
if err != nil {
	panic(err.Error())
}
```

## RequestOptions

Esta biblioteca usa o padrão de opções funcionais. Funções definidas no pacote `option` retornam um `RequestOption`, que é um closure que modifica uma `RequestConfig`. Essas opções podem ser fornecidas ao cliente ou em requisições individuais. Por exemplo:

```go
client := anthropic.NewClient(
	// Adiciona um cabeçalho a cada requisição feita pelo cliente
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Messages.New(context.TODO(), // ...,
	// Sobrescreve o cabeçalho
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Adiciona um campo não documentado ao corpo da requisição, usando a sintaxe sjson
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)
```

A opção de requisição `option.WithDebugLog(nil)` pode ser útil durante a depuração.

Consulte a [lista completa de opções de requisição](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go/option).

## Personalização do cliente HTTP

Para middleware de requisição (`option.WithMiddleware`) e substituição do `http.Client` padrão (`option.WithHTTPClient`), consulte [middleware do SDK](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/middleware).

## Integrações de plataforma

<Note>
  Para guias detalhados de configuração de plataforma com exemplos de código, consulte:

  * [Amazon Bedrock](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-amazon-bedrock)
  * [Amazon Bedrock (Opus 4.6 e anteriores)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-amazon-bedrock-legacy)
  * [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws)
  * [Google Cloud](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-on-vertex-ai)
  * [Microsoft Foundry](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-microsoft-foundry)
</Note>

O SDK Go suporta as seguintes plataformas:

* **Agent Platform:** `import "github.com/anthropics/anthropic-sdk-go/vertex"`. Use `vertex.WithGoogleAuth(ctx, region, projectID)` ou `vertex.WithCredentials(ctx, region, projectID, creds)`.
* **Bedrock:** `import "github.com/anthropics/anthropic-sdk-go/bedrock"`. Use `bedrock.NewMantleClient` para o endpoint Bedrock da Messages-API (transmite via SSE), ou `bedrock.WithLoadDefaultConfig(ctx)` / `bedrock.WithConfig(cfg)` (caminho `bedrock-runtime`). Importar o pacote `bedrock` registra globalmente um decodificador para `application/vnd.amazon.eventstream` com a camada de streaming do SDK (através do `init()` do pacote). Isso se aplica quer você use o caminho `WithConfig`/`WithLoadDefaultConfig` do `bedrock-runtime` ou `NewMantleClient`.
* **Claude Platform on AWS:** `import anthropicaws "github.com/anthropics/anthropic-sdk-go/aws"`. Use `anthropicaws.NewClient(ctx, cfg)` com um valor `anthropicaws.ClientConfig` para construir um cliente; defina `WorkspaceID` na configuração ou a variável de ambiente `ANTHROPIC_AWS_WORKSPACE_ID`. O alias de importação `anthropicaws` evita uma colisão de nomes com `github.com/aws/aws-sdk-go-v2/aws` quando ambos são importados. Disponível em beta.
* **Foundry:** `import "github.com/anthropics/anthropic-sdk-go/foundry"`. Use `foundry.NewClient(cfg)` com um valor `foundry.ClientConfig` para construir um cliente; defina `APIKey` (ou `AzureADTokenProvider` para Microsoft Entra ID) e `Resource` na configuração, ou as variáveis de ambiente `ANTHROPIC_FOUNDRY_API_KEY` e `ANTHROPIC_FOUNDRY_RESOURCE`.

Use `bedrock.NewMantleClient` para novos projetos; `bedrock.WithLoadDefaultConfig`/`WithConfig` permanecem para aplicações existentes usando a API `InvokeModel` do Bedrock.

## Uso avançado

### Acessando dados brutos de resposta (por exemplo, cabeçalhos de resposta)

Você pode acessar os dados brutos da resposta HTTP usando a opção de requisição `option.WithResponseInto()`. Isso é útil quando você precisa examinar cabeçalhos de resposta, códigos de status ou outros detalhes.

```go
// Cria uma variável para armazenar a resposta 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_5,
	},
	option.WithResponseInto(&response),
)
if err != nil {
	// trata o erro
}
fmt.Printf("%+v\n", message.Content)

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

### Fazendo requisições personalizadas/não documentadas

Esta biblioteca é tipada para acesso conveniente à API documentada. Se você precisar acessar endpoints, params ou propriedades de resposta não documentados, a biblioteca ainda pode ser usada.

#### Endpoints não documentados

Para fazer requisições a endpoints não documentados, você pode usar `client.Get`, `client.Post` e outros verbos HTTP. `RequestOptions` no cliente, como novas tentativas, serão respeitadas ao fazer essas requisições.

```go
var (
	// params pode ser um io.Reader, um []byte, um objeto serializável por encoding/json,
	// ou uma struct "...Params" definida nesta biblioteca.
	params map[string]any

	// result pode ser um []byte, *http.Response, um objeto desserializável por encoding/json,
	// ou um modelo definido nesta biblioteca.
	result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
	// ...
}
```

#### Params de requisição não documentados

Para fazer requisições usando parâmetros não documentados, você pode usar os métodos `option.WithQuerySet()` ou `option.WithJSONSet()`.

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

#### Propriedades de resposta não documentadas

Para acessar propriedades de resposta não documentadas, você pode acessar o JSON bruto da resposta como uma string com `result.JSON.RawJSON()`, ou obter o JSON bruto de um campo específico no resultado com `result.JSON.Foo.Raw()`.

Quaisquer campos que não estejam presentes na struct de resposta são salvos e podem ser acessados através de `result.JSON.ExtraFields`, que é um `map[string]respjson.Field`.

## Versionamento semântico

Este pacote geralmente segue as convenções [SemVer](https://semver.org/spec/v2.0.0.html), embora certas mudanças incompatíveis com versões anteriores possam ser lançadas como versões menores:

1. Mudanças nos internos da biblioteca que são tecnicamente públicos, mas não destinados ou documentados para uso externo.
2. Mudanças que não se espera que impactem a grande maioria dos usuários na prática.

A compatibilidade com versões anteriores é levada a sério para garantir que você possa contar com uma experiência de atualização tranquila.

Seu feedback é bem-vindo; abra uma [issue](https://github.com/anthropics/anthropic-sdk-go/issues) com perguntas, bugs ou sugestões.

## Recursos adicionais

* [Repositório GitHub](https://github.com/anthropics/anthropic-sdk-go)
* [Documentação do pacote Go](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go)
* [Referência da API](https://platform.claude.com/docs/pt-BR/api/overview)
* [Streaming de Messages](https://platform.claude.com/docs/pt-BR/build-with-claude/streaming)