--- title: SDK de Go url: https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/go description: 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. Para consultar la documentación de las funciones de la API con ejemplos de código, consulta la [referencia de la API](https://platform.claude.com/docs/es/api/overview). Esta página cubre las funciones y la configuración específicas del SDK de Go. ## Instalación ```go import ( "github.com/anthropics/anthropic-sdk-go" // imported as anthropic ) ``` Instala con `go get`: ```bash go get github.com/anthropics/anthropic-sdk-go ``` ## Requisitos Esta biblioteca requiere 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 conocer las opciones de autenticación, incluida "Workload Identity Federation" (federación de identidades de carga de trabajo), consulta [Autenticación](https://platform.claude.com/docs/es/manage-claude/authentication). Si tu "API key" (clave de API) es una [clave personal o de cuenta de servicio](https://platform.claude.com/docs/es/manage-claude/authentication#key-types) que no está limitada a un espacio de trabajo, establece el ID del espacio de trabajo en el encabezado de solicitud `anthropic-workspace-id`; [Seleccionar un espacio de trabajo](https://platform.claude.com/docs/es/manage-claude/authentication#select-a-workspace) muestra la opción por solicitud para este SDK. ```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) ``` ```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) ``` ```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()) } ``` ```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...)) } ``` ## Campos de solicitud La biblioteca de Anthropic usa la semántica de [`omitzero`](https://tip.golang.org/doc/go1.24#encodingjsonpkgencodingjson) 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`. ```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 // ... 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]()`. ```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 ``` 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. Por razones de seguridad, usa `SetExtraFields` solo con datos de confianza. 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)`). ```go // 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. ```go // 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 `param.SetJSON` requiere la versión v1.20.0 del SDK o posterior. 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: ```go // 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, ¶ms) // 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. ```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 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. ```go 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. ```go 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"`. ```go 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`: ```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) { ... } } ``` 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: ```go // 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](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/go#retries), el tiempo de espera del contexto no se reinicia. Para establecer un tiempo de espera por reintento, usa `option.WithRequestTimeout()`. ```go // 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 Considera usar la API de Messages con streaming para solicitudes de mayor duración. 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](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/go#timeouts) 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](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/go#timeouts) 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. ```go // 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: ```go 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()`: ```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 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: ```go 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](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go/option). ## 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](https://platform.claude.com/docs/es/cli-sdks-libraries/middleware). ## Integraciones de plataforma Para guías detalladas de configuración de plataformas con ejemplos de código, consulta: * [Amazon Bedrock](https://platform.claude.com/docs/es/build-with-claude/claude-in-amazon-bedrock) * [Amazon Bedrock (Opus 4.6 y anteriores)](https://platform.claude.com/docs/es/build-with-claude/claude-on-amazon-bedrock-legacy) * [Claude Platform en AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws) * [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/google-managed) * [Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry) Consulta también [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed). 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](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution) 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. ```go // 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) ``` ### Trazado de OpenTelemetry Cuando tu aplicación registra un tracer provider de OpenTelemetry, el SDK emite un span por cada solicitud que envía. Para enviar los spans a tu plataforma de observabilidad, consulta [Configura OpenTelemetry con el Claude SDK](https://platform.claude.com/docs/es/manage-claude/opentelemetry/sdk). ### 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. ```go 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()`. ```go 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](https://platform.claude.com/docs/es/api/migration-2026-10-21#upgrade). Este paquete generalmente sigue las convenciones de [SemVer](https://semver.org/spec/v2.0.0.html), aunque ciertos cambios incompatibles con versiones anteriores pueden publicarse como versiones menores: 1. 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. 2. 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](https://github.com/anthropics/anthropic-sdk-go/issues) con preguntas, errores o sugerencias. ## Recursos adicionales * [Repositorio de GitHub](https://github.com/anthropics/anthropic-sdk-go) * [Documentación del paquete de Go](https://pkg.go.dev/github.com/anthropics/anthropic-sdk-go) * [Referencia de la API](https://platform.claude.com/docs/es/api/overview) * [Streaming de Messages](https://platform.claude.com/docs/es/build-with-claude/streaming)