Solicitud y uso de la API de Claude Messages

Anthropic Claude es un sistema de conversación AI muy potente, que puede generar respuestas fluidas y naturales en cuestión de segundos al ingresar un mensaje. La API de Claude Messages es el formato nativo oficial de Anthropic, que, a diferencia del formato compatible con OpenAI (Chat Completion), utiliza su propia estructura de solicitud y respuesta, lo que permite aprovechar mejor las capacidades únicas de Claude, como la entrada de contenido multimodal, la llamada a herramientas, el pensamiento profundo (Extended Thinking) y otras características avanzadas. Este documento describe principalmente el proceso de uso de la API de Claude Messages, que nos permite utilizar una interfaz nativa consistente con la oficial de Anthropic para invocar las funciones de conversación de Claude.

Proceso de solicitud

Para usar la API de Claude Messages, primero dirígete a Ace Data Cloud Console para obtener tu token de API, que debes guardar para uso futuro.

Si aún no has iniciado sesión o registrado, serás redirigido automáticamente a la página de inicio de sesión que te invitará a registrarte e iniciar sesión; una vez completado, volverás automáticamente a la página actual. Un token de API es suficiente para acceder a todos los servicios de la plataforma, sin necesidad de solicitar uno por cada servicio. La primera solicitud te otorgará un crédito gratuito para que puedas probarlo; si el crédito es insuficiente, puedes recargar el saldo general en la consola.

📘 Documentación completa: Claude Messages API →

Uso básico

La ruta de solicitud de la API de Claude Messages es /v1/messages, manteniendo la consistencia con la API oficial de Anthropic. Necesitamos proporcionar al menos tres parámetros obligatorios:

model: seleccionar el modelo de Claude a utilizar. El último modelo insignia es claude-fable-5-1 (contexto de 1 millón de tokens, salida máxima de 128K tokens); el modelo original claude-fable-5 sigue siendo compatible.
messages: un array de mensajes de entrada, donde cada mensaje incluye role (rol) y content (contenido), siendo role compatible con user y assistant.
max_tokens: número máximo de tokens de salida, utilizado para limitar la longitud de la respuesta única.

Parámetros opcionales comunes:

system: mensaje del sistema, utilizado para establecer el comportamiento y rol del modelo.
temperature: aleatoriedad de la generación, entre 0 y 1, donde un valor mayor produce respuestas más dispersas.
stream: si se utiliza respuesta en streaming, establecer en true permite un efecto de retorno palabra por palabra.
stop_sequences: secuencias de parada personalizadas, el modelo dejará de generar al encontrar estos textos.
top_p: parámetro de muestreo nuclear, que junto con la temperatura controla la aleatoriedad de la generación.
top_k: muestreo solo de las K opciones con mayor probabilidad.
tools: definición de herramientas, para permitir que el modelo llame a funciones externas.
tool_choice: controla cómo el modelo utiliza las herramientas proporcionadas.
cache_control: crea automáticamente un punto de caché en el último bloque de contenido que se puede almacenar en caché; también se puede escribir en bloques de contenido específicos.

Ejemplo de cURL

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Hello, Claude"
      }
    ]
  }'

Ejemplo de Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Hello, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Después de la llamada, el resultado devuelto es el siguiente:

{
  "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hi! My name is Claude. How can I help you today?"
    }
  ],
  "model": "claude-opus-4-8",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 12,
    "output_tokens": 15
  }
}

Descripción de los campos del resultado devuelto:

id: identificador único del mensaje actual.
type: siempre es message.
role: siempre es assistant.
content: array de contenido de respuesta, donde cada elemento incluye type (como text) y el contenido correspondiente.
model: nombre del modelo que procesó la solicitud.
stop_reason: razón de la detención. Los valores estables incluyen end_turn, max_tokens, stop_sequence, tool_use, pause_turn (puede devolver el contenido actual del assistant tal cual para continuar), refusal y model_context_window_exceeded.
stop_sequence: si se detuvo debido a una secuencia de parada personalizada, muestra el texto de la secuencia de parada coincidente.
stop_details: cuando stop_reason es refusal, puede incluir la categoría de rechazo y la explicación.
usage: estadísticas de uso de tokens. input_tokens son los tokens de entrada no almacenados en caché; cache_creation_input_tokens y cache_read_input_tokens son respectivamente los tokens de entrada para escritura y lectura en caché; output_tokens es el número de tokens de salida. La tarifa base oficial de lectura de caché para Fable 5.1 es de $0.25/millón de tokens, y las tarifas de escritura en caché para 5 minutos y 1 hora son de$ 12.50 y $20/millón de tokens respectivamente; los precios reales de la plataforma se calculan según los descuentos del paquete. Las respuestas no en streaming también pueden incluir el cost registrado por Ace Data Cloud.

Mensajes del sistema

La API de Claude Messages permite establecer mensajes del sistema a través del campo system, utilizado para definir el comportamiento, rol y contexto del modelo.

Ejemplo de Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "system": "Eres un asistente de traducción profesional en chino, por favor traduce el inglés ingresado por el usuario al chino.",
    "messages": [
        {"role": "user", "content": "The quick brown fox jumps over the lazy dog."}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Al establecer el mensaje system, se puede controlar con precisión el rol y el comportamiento de Claude.

Respuesta en streaming

Esta interfaz también admite respuestas en streaming; al establecer el parámetro stream en true, se puede obtener un efecto de retorno paso a paso, lo que es muy adecuado para implementar la visualización palabra por palabra en una página web.

Ejemplo de Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "stream": True,
    "messages": [
        {"role": "user", "content": "Hola, Claude"}
    ]
}

response = requests.post(url, json=payload, headers=headers, stream=True)
for line in response.iter_lines():
    if line:
        print(line.decode("utf-8"))

La respuesta en streaming se devuelve en formato de Eventos Enviados por el Servidor (SSE), cada línea precedida por event: y data:. Los tipos de eventos en streaming incluyen:

message_start: inicio del mensaje, que contiene la información básica del mensaje y el nombre del modelo.
content_block_start: inicio del bloque de contenido.
content_block_delta: actualización incremental del bloque de contenido, que contiene fragmentos de texto generados recientemente.
content_block_stop: fin del bloque de contenido.
message_delta: actualización incremental a nivel de mensaje, que incluye stop_reason e información final de usage.
message_stop: fin del mensaje.

El resultado de salida es el siguiente:

event: message_start
data: {"type":"message_start","message":{"id":"msg_01XFDUDYJgAACzvnptvVoYEL","type":"message","role":"assistant","content":[],"model":"claude-sonnet-4-20250514","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":12,"output_tokens":0}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hola"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"! Mi nombre es"}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":" Claude. ¿Cómo puedo ayudarte hoy?"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":15}}

event: message_stop
data: {"type":"message_stop"}

Como se puede ver, el evento content_block_delta en la respuesta en streaming contiene el contenido de texto generado paso a paso, y al concatenar todos los text_delta se puede obtener la respuesta completa.

Ejemplo de JavaScript

const options = {
  method: "POST",
  headers: {
    accept: "application/json",
    authorization: "Bearer {token}",
    "content-type": "application/json",
  },
  body: JSON.stringify({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    stream: true,
    messages: [{ role: "user", content: "Hola, Claude" }],
  }),
};

const response = await fetch("https://api.acedata.cloud/v1/messages", options);
const reader = response.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value));
}

Diálogo de múltiples turnos

Si desea habilitar la función de diálogo de múltiples turnos, debe alternar los mensajes de los roles user y assistant en el array messages, incluyendo el historial de conversación anterior.

Ejemplo en Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {"role": "user", "content": "Hola, mi nombre es Alice."},
        {"role": "assistant", "content": "¡Hola Alice! Encantado de conocerte. ¿Cómo puedo ayudarte hoy?"},
        {"role": "user", "content": "¿Cuál es mi nombre?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

El resultado devuelto es el siguiente:

{
  "id": "msg_01Y1wfQmd89g968TVbFu57Yc",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Tu nombre es Alice, ¡como acabas de decirme!"
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 40,
    "output_tokens": 14
  }
}

Al pasar el historial completo de la conversación en messages, Claude puede proporcionar respuestas precisas en función del contexto.

Modelo de pensamiento profundo

El pensamiento de Claude y el resumen del pensamiento son dos conceptos diferentes: el modelo puede realizar inferencias internas, pero la API no devolverá la cadena de pensamiento original. Cuando se necesita mostrar el proceso de razonamiento, la API devuelve un resumen procesado. El modelo actual sugiere usar pensamiento adaptativo y controlar la inversión total de razonamiento a través de output_config.effort:

import requests

url = "https://api.acedata.cloud/v1/messages"
headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}
payload = {
    "model": "claude-opus-5",
    "max_tokens": 16000,
    "thinking": {
        "type": "adaptive",
        "display": "summarized"
    },
    "output_config": {
        "effort": "high"
    },
    "messages": [
        {"role": "user", "content": "¿Cuál es el seno de 30 grados?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

El bloque de pensamiento en la respuesta tiene la forma:

{
  "type": "thinking",
  "thinking": "El problema pide un valor trigonométrico estándar...",
  "signature": "opaque-signature"
}

display: "summarized" devuelve un resumen de pensamiento legible; no es la cadena de pensamiento original.
display: "omitted" devuelve thinking: "", pero aún conserva la signature opaca para soportar diálogos posteriores.
Los modelos Fable 5.1, Fable 5, Opus 5, Sonnet 5, Opus 4.8 y Opus 4.7 tienen un valor predeterminado de omitted para display; los modelos Opus 4.6, Sonnet 4.6 y anteriores que soportan pensamiento utilizan por defecto summarized.
Display solo afecta el contenido devuelto y la latencia en streaming, no cierra el razonamiento ni reduce la facturación de tokens de pensamiento.
Si el pensamiento se habilita por defecto y el valor predeterminado de display son dos cuestiones independientes. Opus 5 y Sonnet 5 habilitan por defecto el pensamiento adaptativo; Opus 4.8, 4.7 y 4.6 necesitan ser habilitados explícitamente.
budget_tokens solo se utiliza para modelos antiguos que aún soportan un presupuesto de pensamiento fijo. Los nuevos modelos deben usar thinking.type=adaptive y output_config.effort; el pensamiento de Fable 5.1 siempre está habilitado y no se puede desactivar explícitamente.
En diálogos de múltiples turnos y llamadas a herramientas, se debe devolver el bloque completo de pensamiento y la firma devueltos por el asistente sin modificaciones; no se debe modificar ni generar la firma por cuenta propia.
Algunas rutas de compatibilidad parcial no pueden manejar redacted_thinking sin pérdida o desactivar explícitamente el pensamiento, en cuyo caso se devolverá un error de parámetro y no se descartará silenciosamente ni se cambiará el significado de la solicitud.

En solicitudes en streaming, summarized generará thinking_delta; omitted no generará thinking_delta, solo conservará el ciclo de vida del bloque de pensamiento y signature_delta.

Modelo visual

Claude admite entradas multimodales y puede procesar texto e imágenes simultáneamente. En la API de Messages, se pueden utilizar capacidades visuales configurando `content` como un formato de array e incluyendo bloques de contenido de imagen.

### Usar imágenes codificadas en Base64

```python
import base64
import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

# Leer y codificar la imagen
with open("image.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "¿Qué hay en esta imagen?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Usar imágenes de URL

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://cdn.acedata.cloud/ueugot.png"
                    }
                },
                {
                    "type": "text",
                    "text": "¿Qué hay en esta imagen?"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Ejemplo de cURL

curl -X POST 'https://api.acedata.cloud/v1/messages' \
  -H 'accept: application/json' \
  -H 'authorization: Bearer {token}' \
  -H 'content-type: application/json' \
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "image",
            "source": {
              "type": "url",
              "url": "https://cdn.acedata.cloud/ueugot.png"
            }
          },
          {
            "type": "text",
            "text": "¿Qué hay en esta imagen?"
          }
        ]
      }
    ]
  }'

Los formatos de imagen admitidos incluyen: image/jpeg, image/png, image/gif, image/webp.

Documentos y PDF

Los PDF utilizan bloques de contenido document, admitiendo fuentes estables en Base64 y URL. La fuente Base64 debe usar application/pdf:

import base64

with open("report.pdf", "rb") as f:
    pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "messages": [{
        "role": "user",
        "content": [
            {
                "type": "document",
                "source": {
                    "type": "base64",
                    "media_type": "application/pdf",
                    "data": pdf_data
                },
                "title": "Informe trimestral"
            },
            {"type": "text", "text": "Resume este PDF."}
        ]
    }]
}

La fuente de URL se escribe como {"type":"url","url":"https://example.com/report.pdf"}. document también admite text/plain y fuentes de content compuestas de bloques de texto/imágenes; los campos opcionales incluyen title, context y citations. La fuente file_id de la API de archivos es una función beta independiente y no está dentro del contrato estable de esta interfaz.

Caché de sugerencias

El cache_control de nivel superior colocará automáticamente el punto de caché en el último bloque que se puede almacenar en caché:

payload = {
    "model": "claude-fable-5-1",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral", "ttl": "5m"},
    "system": "Eres un experto en este material de referencia.",
    "messages": [{"role": "user", "content": "Resume los puntos clave."}]
}

Cuando se necesita un control preciso de la ubicación, también se puede escribir el mismo cache_control en los bloques de contenido de texto, imagen, documento, uso de herramientas, resultado de herramientas o definiciones de herramientas. ttl admite 5m (predeterminado) y 1h; se debe determinar la escritura y el acierto de la caché a través de usage.cache_creation_input_tokens y usage.cache_read_input_tokens. Ejemplo de resultado devuelto:

{
  "id": "msg_01NCrxpZmV17bhQJJRQEFEb9",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Esta imagen muestra una interfaz de configuración de solicitud de API para lo que parece ser un servicio de finalización de chat de IA. La interfaz incluye parámetros para la selección de modelo, mensajes, modo de transmisión y configuraciones de tokens máximos."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 1570,
    "output_tokens": 52
  }
}

Llamadas a herramientas (Tool Use)

La API de Messages de Claude admite de forma nativa la función de llamadas a herramientas, permitiendo que el modelo llame a herramientas/funciones predefinidas cuando sea necesario.

Ejemplo en Python

import requests

url = "https://api.acedata.cloud/v1/messages"

headers = {
    "accept": "application/json",
    "authorization": "Bearer {token}",
    "content-type": "application/json"
}

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Obtener el clima actual en una ubicación dada",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "La ciudad y el estado, por ejemplo, San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "¿Cómo está el clima en San Francisco?"}
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Cuando el modelo decide llamar a una herramienta, el content en el resultado devuelto incluirá un bloque de contenido de tipo tool_use:

{
  "id": "msg_01Aq9w938a90dw8q",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Déjame verificar el clima en San Francisco para ti."
    },
    {
      "type": "tool_use",
      "id": "toolu_01A09q90qw90lq917835lgs",
      "name": "get_weather",
      "input": {
        "location": "San Francisco, CA"
      }
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "tool_use",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 120,
    "output_tokens": 68
  }
}

Nota que stop_reason es tool_use, lo que indica que el modelo necesita llamar a una herramienta. Al recibir este resultado, debe ejecutar la función de la herramienta y devolver el resultado en forma de tool_result al modelo:

payload = {
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "tools": [
        {
            "name": "get_weather",
            "description": "Obtener el clima actual en una ubicación dada",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "La ciudad y el estado, por ejemplo, San Francisco, CA"
                    }
                },
                "required": ["location"]
            }
        }
    ],
    "messages": [
        {"role": "user", "content": "¿Cómo está el clima en San Francisco?"},
        {
            "role": "assistant",
            "content": [
                {"type": "text", "text": "Déjame verificar el clima en San Francisco para ti."},
                {"type": "tool_use", "id": "toolu_01A09q90qw90lq917835lgs", "name": "get_weather", "input": {"location": "San Francisco, CA"}}
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01A09q90qw90lq917835lgs",
                    "content": "Soleado, 72°F"
                }
            ]
        }
    ]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

El modelo generará la respuesta final en lenguaje natural basada en los resultados devueltos por la herramienta.

Diferencias con la API de Chat Completion

Ace Data Cloud ofrece dos formatos de API de Claude, y las principales diferencias son las siguientes: El usage.input_tokens de la API de Messages solo representa la entrada no almacenada en caché, cache_read_input_tokens y cache_creation_input_tokens son contadores de facturación independientes; los tres se calcularán por separado según el precio correspondiente.

Característica	API de Messages (`/v1/messages`)	API de Chat Completion (`/v1/chat/completions`)
Formato	Formato nativo de Anthropic	Formato compatible con OpenAI
Prompt del sistema	Campo `system` independiente	Pasado a través de `messages` en `role: "system"`
Estructura de respuesta	Array `content` (soporta varios tipos)	Array `choices` (contiene `message`)
Formato de flujo	Eventos SSE (varios tipos de eventos)	Línea SSE `data`
Pensamiento profundo	Parámetro `thinking` nativo	Activado a través de un nombre de modelo especial (como el sufijo `-thinking`)
Llamadas a herramientas	`tools` nativo + `input_schema`	Formato `functions` compatible con OpenAI
Estadísticas de Token	`input_tokens` / `output_tokens`	`prompt_tokens` / `completion_tokens`

Si su sistema ya está integrado con la API en formato OpenAI, puede usar la API de Chat Completion para una transición sin problemas. Si necesita utilizar todas las capacidades nativas de Claude, se recomienda usar la API de Messages.

Manejo de errores

Las respuestas de error de la interfaz pública utilizan el sobre de la plataforma Ace Data Cloud: error.code es un código de error estable, error.message es una descripción, y trace_id se utiliza para investigar la solicitud. Los estados HTTP comunes incluyen:

400: Parámetros de solicitud o contenido del protocolo no válidos.
401: Token de autorización no válido, faltante o expirado.
403: Acceso prohibido, saldo insuficiente o cuota limitada.
404: API o modelo no existe.
413: Cuerpo de solicitud demasiado grande.
429: Demasiadas solicitudes.
500 / 503 / 504: Error del servicio, temporalmente no disponible o tiempo de procesamiento agotado.

Ejemplo de respuesta de error

{
  "error": {
    "code": "api_error",
    "message": "la recuperación falló"
  },
  "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89"
}

Esta estructura de error es el contrato de tiempo de ejecución de Ace Data Cloud, no es equivalente al sobre de error oficial de Anthropic; maneje según el estado HTTP y error.code.

Conclusión

A través de este documento, ha aprendido cómo utilizar la API de Messages de Claude en formato nativo de Anthropic para invocar las funciones de conversación de Claude. La API de Messages admite funciones ricas como conversación básica, prompts del sistema, respuestas en flujo, conversaciones de múltiples turnos, pensamiento profundo, comprensión visual, PDF, almacenamiento en caché de prompts y llamadas a herramientas. Si tiene alguna pregunta, no dude en ponerse en contacto con nuestro equipo de soporte técnico.

Primeros pasos

Chat de IA

Imagen de IA

Video de IA

Audio de IA

Web y datos

CAPTCHA

Identidad

Proxy

Avanzado

Coding

Solicitud y uso de la API de Claude Messages

Proceso de solicitud

Uso básico

Ejemplo de cURL

Ejemplo de Python

Mensajes del sistema

Ejemplo de Python

Respuesta en streaming

Ejemplo de Python

Ejemplo de JavaScript

Diálogo de múltiples turnos

Ejemplo en Python

Modelo de pensamiento profundo

Modelo visual

Usar imágenes de URL

Ejemplo de cURL

Documentos y PDF

Caché de sugerencias

Llamadas a herramientas (Tool Use)

Ejemplo en Python

Diferencias con la API de Chat Completion

Manejo de errores

Ejemplo de respuesta de error

Conclusión

​Proceso de solicitud

​Uso básico

​Ejemplo de cURL

​Ejemplo de Python

​Mensajes del sistema

​Ejemplo de Python

​Respuesta en streaming

​Ejemplo de Python

​Ejemplo de JavaScript

​Diálogo de múltiples turnos

​Ejemplo en Python

​Modelo de pensamiento profundo

​Modelo visual

​Usar imágenes de URL

​Ejemplo de cURL

​Documentos y PDF

​Caché de sugerencias

​Llamadas a herramientas (Tool Use)

​Ejemplo en Python

​Diferencias con la API de Chat Completion

​Manejo de errores

​Ejemplo de respuesta de error

​Conclusión

Proceso de solicitud

Uso básico

Ejemplo de cURL

Ejemplo de Python

Mensajes del sistema

Ejemplo de Python

Respuesta en streaming

Ejemplo de Python

Ejemplo de JavaScript

Diálogo de múltiples turnos

Ejemplo en Python

Modelo de pensamiento profundo

Modelo visual

Usar imágenes de URL

Ejemplo de cURL

Documentos y PDF

Caché de sugerencias

Llamadas a herramientas (Tool Use)

Ejemplo en Python

Diferencias con la API de Chat Completion

Manejo de errores

Ejemplo de respuesta de error

Conclusión