---
title: Python SDK
url: https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/python
description: Instala y configura el SDK de Python de Anthropic con soporte para clientes síncronos y asíncronos
---

El SDK de Python de Anthropic proporciona acceso conveniente a la API de Claude desde aplicaciones Python. Admite operaciones síncronas y asíncronas, "streaming" (transmisión en flujo) e integraciones con Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Anthropic managed), Claude Models on Google Cloud (Google managed) y Microsoft Foundry.

<Info>
  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 Python.
</Info>

## Instalación

```bash
pip install anthropic
```

Para integraciones específicas de plataforma o un mejor rendimiento asíncrono, instala con extras:

```bash
# Para compatibilidad con Amazon Bedrock
pip install "anthropic[bedrock]"

# Para compatibilidad con Google Cloud
pip install "anthropic[vertex]"

# Para compatibilidad con Claude Platform en AWS
pip install "anthropic[aws]"

# La compatibilidad con Microsoft Foundry está incluida en el paquete base

# Para mejorar el rendimiento asíncrono con aiohttp
pip install "anthropic[aiohttp]"
```

Para usar Claude Models on Google Cloud (Anthropic managed), ejecuta `pip install "anthropic[google_cloud]"`.

## Requisitos

Se requiere Python 3.10 o posterior. Si estás actualizando desde una versión 0.x del SDK, consulta la [guía de migración a v1](https://github.com/anthropics/anthropic-sdk-python/blob/main/MIGRATION.md) para ver la lista de cambios incompatibles.

## Uso

```python
import os
from anthropic import Anthropic

client = Anthropic(
    # Este es el valor predeterminado y se puede omitir
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)

message = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
)

for block in message.content:
    if block.type == "text":
        print(block.text)
```

<Tip>
  Considera usar [python-dotenv](https://pypi.org/project/python-dotenv/) para agregar `ANTHROPIC_API_KEY="my-anthropic-api-key"` a tu archivo `.env` de modo que tu clave de API no se almacene en el control de código fuente.
</Tip>

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.

## Uso asíncrono

```python
import os
import asyncio
from anthropic import AsyncAnthropic

client = AsyncAnthropic(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
)


async def main() -> None:
    message = await client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Hello, Claude",
            }
        ],
        model="claude-opus-5-5",
    )
    print(message.content)


asyncio.run(main())
```

### Uso de aiohttp para una mejor concurrencia

Para mejorar el rendimiento asíncrono, puedes usar el backend HTTP `aiohttp` en lugar del predeterminado `httpx2`:

```python
import os
import asyncio
from anthropic import AsyncAnthropic, DefaultAioHttpClient


async def main() -> None:
    async with AsyncAnthropic(
        api_key=os.environ.get("ANTHROPIC_API_KEY"),
        http_client=DefaultAioHttpClient(),
    ) as client:
        message = await client.messages.create(
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": "Hello, Claude",
                }
            ],
            model="claude-opus-5-5",
        )
        print(message.content)


asyncio.run(main())
```

## Respuestas en streaming

El SDK proporciona soporte para respuestas en streaming mediante "Server-Sent Events" (eventos enviados por el servidor), o SSE.

```python
client = Anthropic()

stream = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
    stream=True,
)
for event in stream:
    print(event.type)
```

El cliente asíncrono usa exactamente la misma interfaz:

```python
client = AsyncAnthropic()

stream = await client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Hello, Claude",
        }
    ],
    model="claude-opus-5-5",
    stream=True,
)
async for event in stream:
    print(event.type)
```

### Ayudantes de streaming

El SDK también proporciona ayudantes de streaming que usan administradores de contexto y dan acceso al texto acumulado y al mensaje final:

```python
async def main() -> None:
    async with client.messages.stream(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Say hello there!",
            }
        ],
        model="claude-opus-5-5",
    ) as stream:
        async for text in stream.text_stream:
            print(text, end="", flush=True)
        print()

        message = await stream.get_final_message()
        print(message.to_json())


asyncio.run(main())
```

El streaming con `client.messages.stream(...)` expone varios ayudantes, incluida la acumulación y eventos específicos del SDK.

Como alternativa, puedes usar `client.messages.create(..., stream=True)`, que solo devuelve un iterable de los eventos del stream y usa menos memoria (no construye un objeto de mensaje final por ti).

## Conteo de tokens

Puedes ver el uso exacto de una solicitud determinada a través de la propiedad de respuesta `usage`:

```python
message = client.messages.create(...)
print(message.usage)
# Usage(input_tokens=25, output_tokens=13)
```

También puedes contar tokens antes de realizar una solicitud:

```python
count = client.messages.count_tokens(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": "Hello, world"}],
)
print(count.input_tokens)  # 10
```

## Uso de herramientas

Este SDK proporciona soporte para el "tool use" (uso de herramientas), también conocido como "function calling" (llamada a funciones). Para obtener más detalles, consulta [Uso de herramientas con Claude](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview).

### Ayudantes de herramientas

El SDK proporciona ayudantes para definir y ejecutar herramientas como funciones puras de Python. El decorador `@beta_tool` genera el esquema de la herramienta a partir de la firma de la función y su docstring:

```python
import json
from anthropic import Anthropic, beta_tool

client = Anthropic()


@beta_tool
def get_weather(location: str) -> str:
    """Get the weather for a given location.

    Args:
        location: The city and state, for example, San Francisco, CA
    Returns:
        A JSON-encoded string with the location, temperature, and weather condition.
    """
    return json.dumps(
        {
            "location": location,
            "temperature": "68°F",
            "condition": "Sunny",
        }
    )


# Usa el tool_runner para gestionar automáticamente las llamadas a herramientas
runner = client.beta.messages.tool_runner(
    max_tokens=1024,
    model="claude-opus-5-5",
    tools=[get_weather],
    messages=[
        {"role": "user", "content": "What is the weather in SF?"},
    ],
)
for message in runner:
    print(message)
```

En cada iteración se realiza una solicitud a la API. Si la respuesta incluye una llamada a una de las herramientas proporcionadas, la herramienta se llama automáticamente y el resultado se devuelve directamente al modelo en la siguiente iteración.

Para ejecutar la herramienta de uso del navegador o la herramienta de uso de computadora con este SDK, consulta [Uso del navegador y de la computadora con los conjuntos de herramientas del SDK](https://platform.claude.com/docs/es/agents-and-tools/tool-use/browser-use-sdk).

## Lotes de mensajes

Este SDK proporciona soporte para el [procesamiento por lotes](https://platform.claude.com/docs/es/build-with-claude/batch-processing) en `client.messages.batches`.

### Crear un lote

Message Batches recibe un arreglo de solicitudes, donde cada objeto tiene un identificador `custom_id` y los mismos `params` de solicitud que la Messages API estándar:

```python
client.messages.batches.create(
    requests=[
        {
            "custom_id": "my-first-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Hello, world"}],
            },
        },
        {
            "custom_id": "my-second-request",
            "params": {
                "model": "claude-opus-5-5",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Hi again, friend"}],
            },
        },
    ]
)
```

### Obtener resultados de un lote

Una vez que un Message Batch se ha procesado, lo cual se indica con `.processing_status == 'ended'`, puedes acceder a los resultados con `.batches.results()`:

```python
client = anthropic.Anthropic()
batch_id = "batch_abc123"
result_stream = client.messages.batches.results(batch_id)
for entry in result_stream:
    if entry.result.type == "succeeded":
        print(entry.result.message.content)
```

## Carga de archivos

Los parámetros de solicitud que corresponden a cargas de archivos se pueden pasar de muchas formas diferentes:

* Un objeto `PathLike` (por ejemplo, `pathlib.Path`)
* Una tupla de `(filename, content, content_type)`
* Un objeto similar a un archivo `BinaryIO`

```python
from pathlib import Path
from anthropic import Anthropic

client = Anthropic()

# Sube usando una ruta de archivo
client.files.upload(
    file=Path("/path/to/file"),
)

# Sube usando bytes
client.files.upload(
    file=("file.txt", b"my bytes", "text/plain"),
)
```

El cliente asíncrono usa exactamente la misma interfaz. Si pasas una instancia de `PathLike`, el contenido del archivo se lee de forma asíncrona automáticamente.

## Manejo de errores

Cuando la biblioteca no puede conectarse a la API, o si la API devuelve un código de estado que no es de éxito (es decir, una respuesta 4xx o 5xx), se genera una subclase de `APIError`:

```python
import anthropic
# ...
try:
    message = client.messages.create(
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Hello, Claude",
            }
        ],
        model="claude-opus-5-5",
    )
except anthropic.APIConnectionError as e:
    print("The server could not be reached")
    print(e.__cause__)  # an underlying Exception, likely raised within httpx2
except anthropic.RateLimitError as e:
    print("A 429 status code was received; we should back off a bit.")
except anthropic.APIStatusError as e:
    print("Another non-200-range status code was received")
    print(e.status_code)
    print(e.response)
```

Los códigos de error son los siguientes:

| Código de estado | Tipo de error              |
| ---------------- | -------------------------- |
| 400              | `BadRequestError`          |
| 401              | `AuthenticationError`      |
| 403              | `PermissionDeniedError`    |
| 404              | `NotFoundError`            |
| 409              | `ConflictError`            |
| 422              | `UnprocessableEntityError` |
| 429              | `RateLimitError`           |
| >=500            | `InternalServerError`      |
| N/A              | `APIConnectionError`       |

## IDs de solicitud

> Para obtener más información sobre la depuración de solicitudes, consulta [ID de solicitud](https://platform.claude.com/docs/es/api/errors#request-id).

Todas las respuestas de objetos en el SDK proporcionan una propiedad `_request_id` que se agrega a partir del encabezado de respuesta `request-id`, para que puedas registrar rápidamente las solicitudes fallidas y reportarlas a Anthropic.

```python
message = client.messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
print(message._request_id)  # e.g., req_018EeWyXxfu5pfWkrYcMdjWG
```

<Note>
  A diferencia de otras propiedades que usan el prefijo `_`, la propiedad `_request_id` es pública. A menos que se documente lo contrario, todas las demás propiedades, métodos y módulos con prefijo `_` son privados.
</Note>

## Reintentos

Ciertos errores se reintentan automáticamente 2 veces de forma predeterminada, con un breve retroceso exponencial. Los errores de conexión (por ejemplo, debido a un problema de conectividad de red), 408 Request Timeout, 409 Conflict, 429 Rate Limit y los errores internos >=500 se reintentan de forma predeterminada.

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

```python
# Configura el valor predeterminado para todas las solicitudes:
client = Anthropic(
    max_retries=0,  # default is 2
)

# O bien, configúralo por solicitud:
client.with_options(max_retries=5).messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
```

## Tiempos de espera

De forma predeterminada, las solicitudes agotan el tiempo de espera después de 10 minutos. Puedes configurar esto con la opción `timeout`, que acepta un float o un objeto `httpx2.Timeout`:

```python
import httpx2
from anthropic import Anthropic

# Configura el valor predeterminado para todas las solicitudes:
client = Anthropic(
    timeout=20.0,  # 20 seconds (default is 10 minutes)
)

# Control más granular:
client = Anthropic(
    timeout=httpx2.Timeout(60.0, read=5.0, write=10.0, connect=2.0),
)

# Sobrescribe por solicitud:
client.with_options(timeout=5.0).messages.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)
```

Cuando se agota el tiempo de espera, el SDK lanza un `APITimeoutError`.

Ten en cuenta que las solicitudes que agotan el tiempo de espera se [reintentan dos veces de forma predeterminada](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/python#retries).

## Solicitudes largas

<Warning>
  Considera usar la [Messages API](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/python#streaming-responses) en streaming para solicitudes de mayor duración.
</Warning>

Evita establecer un valor grande de `max_tokens` sin usar streaming. 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/python#timeouts) sin recibir una respuesta de Anthropic.

El SDK lanzará un `ValueError` si se espera que una solicitud sin streaming tarde más de aproximadamente 10 minutos. Pasar `stream=True` o sobrescribir la opción `timeout` a nivel de cliente o de solicitud desactiva este error.

Una latencia de solicitud esperada mayor que el [tiempo de espera](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/python#timeouts) para una solicitud sin streaming hará que el cliente termine la conexión y reintente sin recibir una respuesta.

El SDK establece una opción de [TCP socket keep-alive](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html) para reducir el impacto de los tiempos de espera de conexiones inactivas en algunas redes. Esto se puede sobrescribir pasando una opción `http_client` personalizada al cliente.

## Paginación automática

Los métodos de listado en la API de Claude están paginados. Puedes usar la sintaxis `for` para iterar a través de los elementos de todas las páginas:

```python
client = Anthropic()

all_batches = []
# Obtiene automáticamente más páginas según sea necesario.
for batch in client.messages.batches.list(limit=20):
    all_batches.append(batch)
print(all_batches)
```

Para la iteración asíncrona:

```python
async def main() -> None:
    all_batches = []
    async for batch in client.messages.batches.list(limit=20):
        all_batches.append(batch)
    print(all_batches)


asyncio.run(main())
```

Como alternativa, puedes usar los métodos `.has_next_page()`, `.next_page_info()` o `.get_next_page()` para un control más granular al trabajar con páginas:

```python
first_page = await client.messages.batches.list(limit=20)

if first_page.has_next_page():
    print(f"will fetch next page using these details: {first_page.next_page_info()}")
    next_page = await first_page.get_next_page()
    print(f"number of items we just fetched: {len(next_page.data)}")

# Elimina `await` para el uso no asíncrono.
```

O trabajar directamente con los datos devueltos:

```python
first_page = await client.messages.batches.list(limit=20)

print(f"next page cursor: {first_page.last_id}")
for batch in first_page.data:
    print(batch.id)

# Elimina `await` para el uso no asíncrono.
```

## Encabezados predeterminados

El SDK envía automáticamente el encabezado `anthropic-version` establecido en la versión de la API correspondiente a esta versión mayor del SDK (consulta [Versionado semántico](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/python#semantic-versioning)).

Si lo necesitas, puedes sobrescribirlo estableciendo encabezados predeterminados en el objeto cliente o por solicitud.

<Warning>
  Sobrescribir los encabezados predeterminados puede provocar tipos incorrectos y otros comportamientos inesperados o indefinidos en el SDK.
</Warning>

```python
# Establece encabezados predeterminados para todas las solicitudes del cliente
client = Anthropic(
    default_headers={"anthropic-version": "My-Custom-Value"},
)

# O sobrescríbelos por solicitud
client.messages.with_raw_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
    extra_headers={"anthropic-version": "My-Custom-Value"},
)
```

## Sistema de tipos

### Parámetros de solicitud

Los parámetros de solicitud anidados son [TypedDicts](https://docs.python.org/3/library/typing.html#typing.TypedDict). Las respuestas son [modelos de Pydantic](https://docs.pydantic.dev) que también tienen métodos auxiliares para cosas como serializar de vuelta a JSON ([`v1`](https://docs.pydantic.dev/1.10/usage/models/), [`v2`](https://docs.pydantic.dev/latest/concepts/serialization/)).

Las solicitudes y respuestas tipadas proporcionan autocompletado y documentación dentro de tu editor. Si quieres ver errores de tipo en VS Code para ayudar a detectar errores antes, establece `python.analysis.typeCheckingMode` en `basic`.

### Modelos de respuesta

Para convertir un modelo de Pydantic en un diccionario, usa los métodos auxiliares:

```python
message = client.messages.create(...)

# Convertir a cadena JSON
json_str = message.to_json()

# Convertir a diccionario
data = message.to_dict()
```

### Manejo de campos nulos frente a campos ausentes

En las respuestas, puedes distinguir entre campos que son explícitamente `null` y campos que no se devolvieron (ausentes):

```python
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
if response.my_field is None:
    if "my_field" not in response.model_fields_set:
        print("field was not in the response")
    else:
        print("field was null")
```

## Uso avanzado

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

Se puede acceder al `Response` "sin procesar" devuelto por `httpx2` a través de la propiedad `.with_raw_response` del cliente. Esto es útil para acceder a los encabezados de respuesta u otros metadatos:

```python
client = Anthropic()

response = client.messages.with_raw_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
)

print(response.headers.get("request-id"))
message = (
    response.parse()
)  # get the object that `messages.create()` would have returned
print(message.content)
```

Estos métodos devuelven un objeto `APIResponse`. En el cliente asíncrono devuelven un `AsyncAPIResponse`, y se debe usar await con `.parse()`, `.read()`, `.text()` y `.json()`.

### Cuerpo de respuesta en streaming

El enfoque `.with_raw_response` lee de forma anticipada el cuerpo completo de la respuesta cuando realizas la solicitud. Para hacer streaming del cuerpo de la respuesta en su lugar, usa `.with_streaming_response`, que requiere un administrador de contexto y solo lee el cuerpo de la respuesta una vez que llamas a `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` o `.parse()`. En el cliente asíncrono, estos son métodos asíncronos.

```python
with client.messages.with_streaming_response.create(
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    model="claude-opus-5-5",
) as response:
    print(response.headers.get("request-id"))

    for line in response.iter_lines():
        print(line)
```

El administrador de contexto es necesario para que la respuesta se cierre de forma confiable.

### Registro

El SDK usa el módulo `logging` de la biblioteca estándar.

Puedes habilitar el registro estableciendo la variable de entorno `ANTHROPIC_LOG` en `debug` o `info`:

```bash
export ANTHROPIC_LOG=debug
```

### 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, la biblioteca aún se puede usar.

#### Endpoints no documentados

Para realizar solicitudes a endpoints no documentados, puedes usar `client.get`, `client.post` y otros verbos HTTP. Las opciones del cliente, como los reintentos, se respetan al realizar estas solicitudes.

```python
import httpx2

response = client.post(
    "/foo",
    cast_to=httpx2.Response,
    body={"my_param": True},
)

print(response.json())
```

#### Parámetros de solicitud no documentados

Si quieres enviar explícitamente un parámetro adicional, puedes hacerlo con las opciones de solicitud `extra_query`, `extra_body` y `extra_headers`.

<Warning>
  Los parámetros `extra_` sobrescriben los parámetros documentados con el mismo nombre. Por razones de seguridad, asegúrate de que estos métodos solo se usen con datos de entrada confiables.
</Warning>

#### Propiedades de respuesta no documentadas

Para acceder a propiedades de respuesta no documentadas, puedes acceder a los campos adicionales como `response.unknown_prop`. También puedes obtener todos los campos adicionales del modelo de Pydantic como un dict con `response.model_extra`.

### Configurar el cliente HTTP

El SDK envía solicitudes con [httpx2](https://httpx2.pydantic.dev), un fork de `httpx` compatible a nivel de API. Para personalizar el cliente HTTP, incluidos proxies y transportes, pasa tu propio [cliente httpx2](https://httpx2.pydantic.dev/api/#client) como `http_client`:

```python
import httpx2
from anthropic import Anthropic, DefaultHttpxClient

client = Anthropic(
    # O usa la variable de entorno `ANTHROPIC_BASE_URL`
    base_url="http://my.test.server.example.com:8083",
    http_client=DefaultHttpxClient(
        proxy="http://my.test.proxy.example.com",
        transport=httpx2.HTTPTransport(local_address="0.0.0.0"),
    ),
)
```

También puedes personalizar el cliente por solicitud usando `with_options()`:

```python
client.with_options(http_client=DefaultHttpxClient(...))
```

<Note>
  Usa `DefaultHttpxClient` y `DefaultAsyncHttpxClient` en lugar de `httpx2.Client` y `httpx2.AsyncClient` sin procesar para asegurarte de que se conserve la configuración predeterminada del SDK (como los tiempos de espera y los límites de conexión). El argumento `http_client` debe ser un cliente de `httpx2`. Pasar un cliente del paquete independiente `httpx` genera un `TypeError`.
</Note>

Las herramientas de rastreo y simulación que parchean el propio `httpx`, como `HTTPXClientInstrumentor` de OpenTelemetry, la integración de `httpx` de Sentry, `respx` o `pytest-httpx`, no ven las solicitudes del SDK de forma predeterminada. Para usarlas, llama a `httpx2.alias_httpx()` una vez al inicio, antes de que cualquier cosa importe `httpx`. Esto hace que `import httpx` se resuelva a `httpx2` para todo el proceso.

### Administrar recursos HTTP

De forma predeterminada, la biblioteca cierra las conexiones HTTP subyacentes cada vez que el cliente es [recolectado por el recolector de basura](https://docs.python.org/3/reference/datamodel.html#object.__del__). Puedes cerrar manualmente el cliente usando el método `.close()` si lo deseas, o con un administrador de contexto que lo cierra al salir.

```python
with Anthropic() as client:
    message = client.messages.create(...)

# El cliente HTTP se cierra automáticamente
```

## Funciones beta

Las funciones beta están disponibles antes del lanzamiento general para obtener comentarios tempranos y probar nuevas funcionalidades. Puedes consultar la disponibilidad de todas las capacidades y herramientas de Claude en la [descripción general de funciones](https://platform.claude.com/docs/es/build-with-claude/overview).

Puedes acceder a la mayoría de las funciones beta de la API a través de la propiedad `beta` del cliente. Para habilitar una función beta en particular, necesitas agregar el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) apropiado al campo `betas` al crear un mensaje.

Por ejemplo, para habilitar la [edición de contexto](https://platform.claude.com/docs/es/build-with-claude/context-editing):

```python
client = Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello, Claude"}],
    betas=["context-management-2025-06-27"],
)
```

## Integraciones de plataforma

<Note>
  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 on 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).
</Note>

Las seis clases de cliente están incluidas en el paquete base `anthropic`:

| Proveedor                                         | Cliente                                        | Dependencias adicionales                |
| ------------------------------------------------- | ---------------------------------------------- | --------------------------------------- |
| Agent Platform                                    | `from anthropic import AnthropicVertex`        | `pip install "anthropic[vertex]"`       |
| Bedrock                                           | `from anthropic import AnthropicBedrockMantle` | `pip install "anthropic[bedrock]"`      |
| Bedrock (ruta `bedrock-runtime`)                  | `from anthropic import AnthropicBedrock`       | `pip install "anthropic[bedrock]"`      |
| Claude Platform on AWS                            | `from anthropic import AnthropicAWS`           | `pip install "anthropic[aws]"`          |
| Claude Models on Google Cloud (Anthropic managed) | `from anthropic import AnthropicGoogleCloud`   | `pip install "anthropic[google_cloud]"` |
| Foundry                                           | `from anthropic import AnthropicFoundry`       | Ninguna                                 |

El cliente `AnthropicAWS` está en beta. Pasa `workspace_id` al constructor o establece la variable de entorno `ANTHROPIC_AWS_WORKSPACE_ID`. El cliente `AnthropicGoogleCloud` también está en beta. Pasa `workspace_id` al constructor 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.

Usa `AnthropicBedrockMantle` para proyectos nuevos; `AnthropicBedrock` se mantiene para las aplicaciones existentes que usan la API `InvokeModel` de Bedrock.

## Versionado semántico

Cada versión mayor de este SDK envía una versión de la API en el encabezado `anthropic-version` de forma predeterminada, y con cada nueva versión de la API llega una nueva versión mayor. La primera versión mayor que envía `2026-10-21` es la 2.0.0; 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 que solo afectan a los tipos estáticos, sin romper el comportamiento en tiempo de ejecución.
2. Cambios en los componentes internos de la biblioteca que técnicamente son públicos, pero que no están destinados ni documentados para uso externo.
3. Cambios que no se espera que afecten en la práctica a la gran mayoría de los usuarios.

### Determinar la versión instalada

Si actualizaste a la versión más reciente pero no ves las nuevas funciones que esperabas, es probable que tu entorno de Python todavía esté usando una versión anterior. Puedes determinar la versión que se está usando en tiempo de ejecución con:

```python
print(anthropic.__version__)
```

## Recursos adicionales

* [Repositorio de GitHub](https://github.com/anthropics/anthropic-sdk-python)
* [Referencia de la API](https://platform.claude.com/docs/es/api/overview)
* [Streaming de mensajes](https://platform.claude.com/docs/es/build-with-claude/streaming)
* [Uso de herramientas con Claude](https://platform.claude.com/docs/es/agents-and-tools/tool-use/overview)