SDK de Go

Instala y configura el SDK de Go de Anthropic con cancelación basada en contexto y opciones funcionales

La biblioteca de Go de Anthropic proporciona acceso conveniente a la API de Claude desde aplicaciones escritas en Go.

Instalación

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

Instala con go get:

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

Requisitos

Esta biblioteca requiere Go 1.24+.

Uso

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 conocer las opciones de autenticación, incluida Workload Identity Federation, consulta Autenticación. Si tu clave de API es una clave personal o de cuenta de servicio con acceso a múltiples espacios de trabajo, establece el ID del espacio de trabajo en el encabezado de solicitud anthropic-workspace-id; Seleccionar un espacio de trabajo muestra la opción por solicitud para este SDK.

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)

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)

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())
}

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...))
}

Campos de solicitud

La biblioteca de Anthropic usa la semántica de omitzero de la versión de encoding/json de Go 1.24+ para los campos de solicitud.

Los campos primitivos obligatorios (como int64 o string) llevan la etiqueta `json:"...,required"`. Estos campos siempre se serializan, incluso sus valores cero.

Los tipos primitivos opcionales están envueltos en un param.Opt[T]. Estos campos se pueden establecer con los constructores proporcionados, como anthropic.String(string) o anthropic.Int(int64).

Cualquier param.Opt[T], map, slice, struct o enum de cadena usa la etiqueta `json:"...,omitzero"`. Su valor cero se considera omitido.

La función param.IsOmitted(any) puede confirmar la presencia de cualquier campo omitzero.

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
		// ... los campos no obligatorios omitidos no se serializarán
	},

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

Para enviar null en lugar de un param.Opt[T], usa param.Null[T](). Para enviar null en lugar de un struct T, usa param.NullStruct[T]().

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

Los structs de solicitud contienen un método .SetExtraFields(map[string]any) que puede enviar campos no conformes en el cuerpo de la solicitud. Los campos adicionales sobrescriben cualquier campo del struct con una clave coincidente.

Para enviar un valor personalizado en lugar de un struct, usa la función genérica param.Override (por ejemplo, param.Override[anthropic.FooParams](12)).

// En los casos en que la API especifica un tipo determinado,
// pero quieres enviar otra cosa, usa [SetExtraFields]:
p.SetExtraFields(map[string]any{
	"x": 0.01, // send "x" as a float instead of int
})

// Envía un número en lugar de un objeto
custom := param.Override[anthropic.FooParams](12)

Uniones de solicitud

Las uniones se representan como un struct con campos con el prefijo "Of" para cada una de sus variantes. Solo un campo puede ser distinto de cero. El campo distinto de cero será el que se serialice.

Se puede acceder a las subpropiedades de la unión mediante métodos del struct de unión. Estos métodos devuelven un puntero al valor, si está presente.

// Solo un campo puede ser distinto de cero; usa param.IsOmitted() para comprobar si un campo está establecido
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},
		},
	},
}

// Modificar un campo
if address := animal.GetOwner().GetAddress(); address != nil {
	address.ZipCode = 94304
}

Deserialización de parámetros

Los tipos de parámetros (tipos que terminan en Param, como MessageNewParams o ToolUnionParam) están diseñados solo para solicitudes salientes. Se serializan correctamente a JSON, pero no admiten completamente la deserialización de ida y vuelta. Si deserializas JSON sin procesar en un struct de parámetros, los campos de unión tipados como OfBashTool20250124 serán nil incluso cuando el JSON subyacente sea válido.

Si necesitas reconstruir parámetros a partir de JSON sin procesar (por ejemplo, desde una base de datos, un middleware o una solicitud anterior), llama a UnmarshalJSON para completar los campos que no son de unión y luego usa param.SetJSON para adjuntar los bytes sin procesar y lograr una reserialización correcta:

// Serializa params (por ejemplo, para almacenarlos o reenviarlos)
b, err := json.Marshal(original)
if err != nil {
	panic(err)
}

// Más tarde, reconstruye params a partir del JSON almacenado
var params anthropic.MessageNewParams
if err := params.UnmarshalJSON(b); err != nil {
	panic(err)
}
param.SetJSON(b, &params)

// params.Model y otros campos escalares se rellenan mediante UnmarshalJSON.
// params.Tools[0].OfBashTool20250124 es nil (la limitación de la unión),
// pero el JSON sin procesar se conserva. Cuando params se vuelve a serializar
// para la llamada a la API, las herramientas se serializan correctamente.
b2, _ := json.Marshal(params)
fmt.Println(string(b) == string(b2)) // true

Para este caso de uso, se prefiere param.SetJSON (disponible desde v1.20.0) sobre el más general param.Override[T](any), porque no requiere especificar el parámetro de tipo y hace explícita la intención de ida y vuelta.

Objetos de respuesta

Todos los campos de los structs de respuesta son tipos de valor ordinarios (no punteros ni envoltorios). Los structs de respuesta también incluyen un campo especial JSON que contiene metadatos sobre cada propiedad.

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 manejar datos opcionales, usa el método .Valid() en el campo JSON. .Valid() devuelve true cuando el campo está presente, no es null y se deserializó correctamente.

Si .Valid() es false, el campo correspondiente tendrá su valor cero.

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

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

// Acceso a campos regulares

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

// Comprobaciones de campos opcionales

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

// Valores JSON sin procesar

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

Estos structs .JSON también incluyen un map ExtraFields que contiene cualquier propiedad de la respuesta JSON que no se haya especificado en el struct. Esto puede ser útil para funciones de la API que aún no están presentes en el SDK.

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

Uniones de respuesta

En las respuestas, las uniones se representan mediante un struct aplanado que contiene todos los campos posibles de cada una de las variantes del objeto. Para convertirlo a una variante, usa el método .AsFooVariant() o el método .AsAny() si está presente.

Si una unión de valores de respuesta contiene valores primitivos, los campos primitivos estarán junto a las propiedades, pero con el prefijo Of y con la etiqueta json:"...,inline".

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

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

// Si es una variante de animal
if animal.Owner.Address.ZipCode == "" {
	panic("missing zip code")
}

// Evalúa la variante con switch
switch variant := animal.AsAny().(type) {
case Dog:
case Cat:
default:
	panic("unexpected type")
}

Manejo de errores

Cuando la API devuelve un código de estado que no es de éxito, el SDK devuelve un error de tipo *anthropic.Error. Este contiene los valores StatusCode, *http.Request y *http.Response de la solicitud, junto con el JSON del cuerpo del error (de forma muy similar a otros objetos de respuesta del SDK). El error también incluye el RequestID de los encabezados de respuesta, que es útil para solucionar problemas con el soporte de Anthropic.

Para manejar errores, usa el patrón errors.As:

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

Cuando ocurren otros errores, se devuelven sin envolver; por ejemplo, si falla el transporte HTTP, podrías recibir *url.Error envolviendo *net.OpError.

Reintentos

Ciertos errores se reintentarán automáticamente 2 veces de forma predeterminada, con un breve retroceso exponencial. De forma predeterminada, el SDK reintenta todos los errores de conexión, 408 Request Timeout, 409 Conflict, 429 Rate Limit y los errores internos >=500.

Puedes usar la opción WithMaxRetries para configurar o desactivar esto:

// Configura el valor predeterminado para todas las solicitudes:
client := anthropic.NewClient(
	option.WithMaxRetries(0), // default is 2
)

// Sobrescríbelo por solicitud:
// ...
	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),
	)

Tiempos de espera

Las solicitudes de Messages sin streaming agotan el tiempo de espera después de 10 minutos de forma predeterminada; las demás solicitudes no tienen un tiempo de espera predeterminado. Usa el contexto para configurar un tiempo de espera para el ciclo de vida de una solicitud.

Ten en cuenta que si una solicitud se reintenta, el tiempo de espera del contexto no se reinicia. Para establecer un tiempo de espera por reintento, usa option.WithRequestTimeout().

// Esto establece el tiempo de espera de la solicitud, incluidos todos los reintentos.
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,
		},
		// Esto establece el tiempo de espera por reintento
		option.WithRequestTimeout(20*time.Second),
	)

Solicitudes largas

Evita establecer un valor grande de MaxTokens sin usar streaming, ya que algunas redes pueden cerrar las conexiones inactivas después de cierto período de tiempo, lo que puede hacer que la solicitud falle o agote el tiempo de espera sin recibir una respuesta de Anthropic.

Este SDK también devolverá un error si se espera que una solicitud sin streaming dure más de aproximadamente 10 minutos. Llamar a .Messages.NewStreaming() o establecer un tiempo de espera personalizado desactiva este error.

Carga de archivos

Los parámetros de solicitud que corresponden a cargas de archivos en solicitudes multipart tienen el tipo io.Reader. El contenido del io.Reader se enviará de forma predeterminada como una parte de formulario multipart con el nombre de archivo anonymous_file y el tipo de contenido application/octet-stream, por lo que el enfoque recomendado es especificar un tipo de contenido personalizado con el helper anthropic.File(reader io.Reader, filename string, contentType string), que envuelve cualquier io.Reader con el nombre de archivo y el tipo de contenido adecuados.

// Un archivo del sistema de archivos
file, err := os.Open("/path/to/file.json")
anthropic.FileUploadParams{
	File: anthropic.File(file, "custom-name.json", "application/json"),
}

// Un archivo a partir de una cadena
anthropic.FileUploadParams{
	File: anthropic.File(strings.NewReader("my file contents"), "custom-name.json", "application/json"),
}

El nombre de archivo y el tipo de contenido también se pueden personalizar implementando Name() string o ContentType() string en el tipo en tiempo de ejecución de io.Reader. Ten en cuenta que os.File implementa Name() string, por lo que un archivo devuelto por os.Open se enviará con el nombre de archivo que tiene en el disco.

Paginación

Esta biblioteca proporciona algunas facilidades para trabajar con endpoints de listas paginadas.

Puedes usar los métodos .ListAutoPaging() para iterar sobre los elementos de todas las páginas:

iter := client.Messages.Batches.ListAutoPaging(context.TODO(), anthropic.MessageBatchListParams{
	Limit: anthropic.Int(20),
})
// Obtiene automáticamente más páginas según sea necesario.
for iter.Next() {
	messageBatch := iter.Current()
	fmt.Println(messageBatch.ID)
}
if err := iter.Err(); err != nil {
	panic(err.Error())
}

O puedes usar los métodos simples .List() para obtener una sola página y recibir un objeto de respuesta estándar con métodos auxiliares adicionales como .GetNextPage():

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 el patrón de opciones funcionales. Las funciones definidas en el paquete option devuelven un RequestOption, que es un closure que modifica un RequestConfig. Estas opciones se pueden proporcionar al cliente o en solicitudes individuales. Por ejemplo:

client := anthropic.NewClient(
	// Agrega un encabezado a cada solicitud realizada por el cliente
	option.WithHeader("X-Some-Header", "custom_header_info"),
)

client.Messages.New(context.TODO(), // ...,
	// Sobrescribe el encabezado
	option.WithHeader("X-Some-Header", "some_other_custom_header_info"),
	// Agrega un campo no documentado al cuerpo de la solicitud, usando la sintaxis de sjson
	option.WithJSONSet("some.json.path", map[string]string{"my": "object"}),
)

La opción de solicitud option.WithDebugLog(nil) puede ser útil durante la depuración.

Consulta la lista completa de opciones de solicitud.

Personalización del cliente HTTP

Para el middleware de solicitudes (option.WithMiddleware) y el reemplazo del http.Client predeterminado (option.WithHTTPClient), consulta middleware del SDK.

Integraciones de plataforma

El SDK de Go admite las siguientes plataformas:

Agent Platform: import "github.com/anthropics/anthropic-sdk-go/vertex". Usa vertex.WithGoogleAuth(ctx, region, projectID) o vertex.WithCredentials(ctx, region, projectID, creds).
Bedrock: import "github.com/anthropics/anthropic-sdk-go/bedrock". Usa bedrock.NewMantleClient para el endpoint de Bedrock de la API de Messages (hace streaming mediante SSE), o bedrock.WithLoadDefaultConfig(ctx) / bedrock.WithConfig(cfg) (ruta bedrock-runtime). Importar el paquete bedrock registra globalmente un decodificador para application/vnd.amazon.eventstream en la capa de streaming del SDK (mediante el init() del paquete). Esto se aplica tanto si usas la ruta WithConfig/WithLoadDefaultConfig de bedrock-runtime como NewMantleClient.
Claude Platform en AWS: import anthropicaws "github.com/anthropics/anthropic-sdk-go/aws". Usa anthropicaws.NewClient(ctx, cfg) con un valor anthropicaws.ClientConfig para construir un cliente; establece WorkspaceID en la configuración o la variable de entorno ANTHROPIC_AWS_WORKSPACE_ID. El alias de importación anthropicaws evita una colisión de nombres con github.com/aws/aws-sdk-go-v2/aws cuando se importan ambos. Disponible en beta.
Foundry: import "github.com/anthropics/anthropic-sdk-go/foundry". Usa foundry.NewClient(cfg) con un valor foundry.ClientConfig para construir un cliente; establece APIKey (o AzureADTokenProvider para Microsoft Entra ID) y Resource en la configuración, o las variables de entorno ANTHROPIC_FOUNDRY_API_KEY y ANTHROPIC_FOUNDRY_RESOURCE.

Usa bedrock.NewMantleClient para proyectos nuevos; bedrock.WithLoadDefaultConfig/WithConfig se mantienen para las aplicaciones existentes que usan la API InvokeModel de Bedrock.

El SDK de Go también es compatible con Claude Models on Google Cloud (Anthropic managed) a través del paquete github.com/anthropics/anthropic-sdk-go/googlecloud. Para construir un cliente, llama a googlecloud.NewClient(ctx, cfg) con un valor googlecloud.ClientConfig. Este cliente está en beta. Establece WorkspaceID en la configuración o establece la variable de entorno ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID. Consulta Resolución del proyecto, la ubicación y el workspace para saber cómo el cliente resuelve el ID del workspace.

Uso avanzado

Acceso a los datos de respuesta sin procesar (por ejemplo, encabezados de respuesta)

Puedes acceder a los datos de respuesta HTTP sin procesar usando la opción de solicitud option.WithResponseInto(). Esto es útil cuando necesitas examinar los encabezados de respuesta, los códigos de estado u otros detalles.

// Crea una variable para almacenar la respuesta 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 {
	// manejar el error
}
fmt.Printf("%+v\n", message.Content)

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

Realizar solicitudes personalizadas/no documentadas

Esta biblioteca está tipada para un acceso conveniente a la API documentada. Si necesitas acceder a endpoints, parámetros o propiedades de respuesta no documentados, aún puedes usar la biblioteca.

Endpoints no documentados

Para realizar solicitudes a endpoints no documentados, puedes usar client.Get, client.Post y otros verbos HTTP. Las RequestOptions del cliente, como los reintentos, se respetarán al realizar estas solicitudes.

var (
	// params puede ser un io.Reader, un []byte, un objeto serializable con encoding/json,
	// o un struct "...Params" definido en esta biblioteca.
	params map[string]any

	// result puede ser un []byte, *http.Response, un objeto deserializable con encoding/json,
	// o un modelo definido en esta biblioteca.
	result *http.Response
)
err := client.Post(context.Background(), "/unspecified", params, &result)
if err != nil {
	// ...
}

Parámetros de solicitud no documentados

Para realizar solicitudes con parámetros no documentados, puedes usar los métodos option.WithQuerySet() o option.WithJSONSet().

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

Propiedades de respuesta no documentadas

Para acceder a propiedades de respuesta no documentadas, puedes acceder al JSON sin procesar de la respuesta como una cadena con result.JSON.RawJSON(), u obtener el JSON sin procesar de un campo concreto del resultado con result.JSON.Foo.Raw().

Todos los campos que no están presentes en el struct de respuesta se guardan y se puede acceder a ellos mediante result.JSON.ExtraFields, que es un map[string]respjson.Field.

Versionado semántico

Cada versión principal de este SDK envía una versión de la API en el encabezado anthropic-version de forma predeterminada, y cada nueva versión de la API viene acompañada de una nueva versión principal. La primera versión principal que envía 2026-10-21 es la 2.0.0, cuya ruta de módulo es github.com/anthropics/anthropic-sdk-go/v2; consulta Migración a la versión de la API 2026-10-21.

Este paquete generalmente sigue las convenciones de SemVer, aunque ciertos cambios incompatibles con versiones anteriores pueden publicarse como versiones menores:

Cambios en los componentes internos de la biblioteca que son técnicamente públicos, pero que no están pensados ni documentados para uso externo.
Cambios que no se espera que afecten en la práctica a la gran mayoría de los usuarios.

La compatibilidad con versiones anteriores se toma en serio para garantizar que puedas contar con una experiencia de actualización fluida.

Tus comentarios son bienvenidos; abre un issue con preguntas, errores o sugerencias.

Instalación

Requisitos

Uso

Conversaciones

Indicaciones del sistema

Streaming

Llamadas a herramientas

Campos de solicitud

Uniones de solicitud

Deserialización de parámetros

Objetos de respuesta

Uniones de respuesta

Manejo de errores

Reintentos

Tiempos de espera

Solicitudes largas

Carga de archivos

Paginación

RequestOptions

Personalización del cliente HTTP

Integraciones de plataforma

Uso avanzado

Acceso a los datos de respuesta sin procesar (por ejemplo, encabezados de respuesta)

Realizar solicitudes personalizadas/no documentadas

Endpoints no documentados

Parámetros de solicitud no documentados

Propiedades de respuesta no documentadas

Versionado semántico

Recursos adicionales