---
title: Compatibilidad con el SDK de OpenAI
url: https://platform.claude.com/docs/es/cli-sdks-libraries/libraries/openai-sdk
description: Anthropic proporciona una capa de compatibilidad que te permite usar el SDK de OpenAI para probar la Claude API. Con unos pocos cambios en el código, puedes evaluar rápidamente las capacidades de los modelos de Anthropic.
---
Esta capa de compatibilidad está destinada principalmente a probar y comparar las capacidades de los modelos, y no se considera una solución a largo plazo ni lista para producción en la mayoría de los casos de uso. Aunque se pretende que siga siendo totalmente funcional y que no tenga cambios incompatibles, la prioridad es la confiabilidad y la eficacia de la [Claude API](https://platform.claude.com/docs/es/api/overview).
Para obtener más información sobre las limitaciones de compatibilidad conocidas, consulta [Limitaciones importantes de compatibilidad con OpenAI](https://platform.claude.com/docs/es/cli-sdks-libraries/libraries/openai-sdk#important-openai-compatibility-limitations).
Si encuentras algún problema con la función de compatibilidad con el SDK de OpenAI, comparte tus comentarios a través de este [formulario de comentarios sobre compatibilidad](https://forms.gle/oQV4McQNiuuNbz9n8).
Para obtener la mejor experiencia y acceso al conjunto completo de funciones de la Claude API ([procesamiento de PDF](https://platform.claude.com/docs/es/build-with-claude/pdf-support), [citas](https://platform.claude.com/docs/es/build-with-claude/citations), [pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking) y ["prompt caching" (almacenamiento en caché de prompts)](https://platform.claude.com/docs/es/build-with-claude/prompt-caching)), usa la [Claude API](https://platform.claude.com/docs/es/api/overview) nativa.
## Primeros pasos con el SDK de OpenAI
Para usar la función de compatibilidad con el SDK de OpenAI, necesitarás:
1. Usar un SDK oficial de OpenAI
2. Cambiar lo siguiente
* Actualiza tu URL base para que apunte a la Claude API
* Reemplaza tu clave de API por una [clave de API de Claude](https://platform.claude.com/settings/keys)
* Si tu clave es una [clave personal o de cuenta de servicio](https://platform.claude.com/docs/es/manage-claude/authentication#key-types) con acceso a varios espacios de trabajo, envía también el encabezado `anthropic-workspace-id` en cada solicitud (por ejemplo, `default_headers` en el SDK de Python o `defaultHeaders` en TypeScript); consulta [Seleccionar un espacio de trabajo](https://platform.claude.com/docs/es/manage-claude/authentication#select-a-workspace)
* Actualiza el nombre de tu modelo para usar un [modelo Claude](https://platform.claude.com/docs/es/models/overview)
3. Revisar las siguientes secciones para saber qué funciones son compatibles
### Ejemplo de inicio rápido
```python Python
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ.get("ANTHROPIC_API_KEY"), # Your Claude API key
base_url="https://api.anthropic.com/v1/", # the Claude API endpoint
)
response = client.chat.completions.create(
model="claude-opus-5-5", # Claude model name
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Who are you?"},
],
)
print(response.choices[0].message.content)
```
```typescript TypeScript
import OpenAI from "openai";
const openai = new OpenAI({
apiKey: process.env.ANTHROPIC_API_KEY, // Your Claude API key
baseURL: "https://api.anthropic.com/v1/" // Claude API endpoint
});
const response = await openai.chat.completions.create({
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: "Who are you?" }
],
model: "claude-opus-5-5" // Claude model name
});
console.log(response.choices[0].message.content);
```
```csharp C#
using System.ClientModel;
using OpenAI;
using OpenAI.Chat;
ChatClient chatClient = new(
model: "claude-opus-5-5", // Claude model name
credential: new ApiKeyCredential(
Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY")), // Your Claude API key
options: new OpenAIClientOptions()
{
Endpoint = new Uri("https://api.anthropic.com/v1/") // the Claude API endpoint
});
ChatCompletion completion = chatClient.CompleteChat(
new SystemChatMessage("You are a helpful assistant."),
new UserChatMessage("Who are you?"));
Console.WriteLine(completion.Content[0].Text);
```
```go Go
package main
import (
"context"
"fmt"
"os"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithAPIKey(os.Getenv("ANTHROPIC_API_KEY")), // Your Claude API key
option.WithBaseURL("https://api.anthropic.com/v1/"), // the Claude API endpoint
)
response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
Model: "claude-opus-5-5", // Claude model name
Messages: []openai.ChatCompletionMessageParamUnion{
openai.SystemMessage("You are a helpful assistant."),
openai.UserMessage("Who are you?"),
},
})
if err != nil {
panic(err)
}
fmt.Println(response.Choices[0].Message.Content)
}
```
```java Java
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
public class QuickStart {
public static void main(String[] args) {
OpenAIClient client = OpenAIOkHttpClient.builder()
.apiKey(System.getenv("ANTHROPIC_API_KEY")) // Your Claude API key
.baseUrl("https://api.anthropic.com/v1/") // the Claude API endpoint
.build();
ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
.model("claude-opus-5-5") // Claude model name
.addSystemMessage("You are a helpful assistant.")
.addUserMessage("Who are you?")
.build();
ChatCompletion completion = client.chat().completions().create(params);
System.out.println(completion.choices().get(0).message().content().orElse(""));
}
}
```
OpenAI no tiene un SDK oficial para PHP. Para usar Claude desde PHP, usa en su lugar el [SDK de Claude para PHP](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/php).
```ruby Ruby
require "openai"
openai = OpenAI::Client.new(
api_key: ENV["ANTHROPIC_API_KEY"], # Your Claude API key
base_url: "https://api.anthropic.com/v1/" # the Claude API endpoint
)
response = openai.chat.completions.create(
model: "claude-opus-5-5", # Claude model name
messages: [
{role: "system", content: "You are a helpful assistant."},
{role: "user", content: "Who are you?"}
]
)
puts response.choices.first.message.content
```
## Limitaciones importantes de compatibilidad con OpenAI
### Comportamiento de la API
Estas son las diferencias más sustanciales con respecto al uso de OpenAI:
* El parámetro `strict` para la llamada de funciones se ignora, lo que significa que no se garantiza que el JSON de "tool use" (uso de herramientas) siga el esquema proporcionado. Para garantizar la conformidad con el esquema, usa la [Claude API nativa con Structured Outputs](https://platform.claude.com/docs/es/build-with-claude/structured-outputs).
* La entrada de audio no es compatible; se ignorará y se eliminará de la entrada
* El almacenamiento en caché de prompts no es compatible, pero sí lo es en los [SDK de Anthropic](https://platform.claude.com/docs/es/cli-sdks-libraries/overview)
* Los mensajes de sistema/desarrollador se elevan y se concatenan en el campo `system` de nivel superior, sin importar dónde aparezcan en la conversación. Para agregar instrucciones del sistema a mitad de una conversación, usa [mensajes del sistema a mitad de la conversación](https://platform.claude.com/docs/es/build-with-claude/mid-conversation-system-messages) en la Claude API nativa.
La mayoría de los campos no compatibles se ignoran silenciosamente en lugar de producir errores. Todos ellos están documentados en las siguientes secciones.
### Consideraciones sobre la calidad de la salida
Si has hecho muchos ajustes a tu prompt, es probable que esté bien afinado específicamente para OpenAI. Considera reelaborarlo para Claude usando la [guía de mejores prácticas de prompting](https://platform.claude.com/docs/es/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Elevación de mensajes de sistema / desarrollador
La mayoría de las entradas del SDK de OpenAI se corresponden claramente de forma directa con los parámetros de la API de Anthropic, pero una diferencia notable es el manejo de los prompts de sistema / desarrollador. Con OpenAI, estos dos prompts pueden colocarse a lo largo de una conversación de chat. La capa de compatibilidad toma todos los mensajes de sistema/desarrollador y los concatena con un único salto de línea (`\n`) entre ellos. Esta cadena completa se proporciona luego como el campo `system` de nivel superior, antes de todos los mensajes.
### Compatibilidad con el pensamiento
Puedes habilitar el [pensamiento](https://platform.claude.com/docs/es/build-with-claude/thinking) agregando el parámetro `thinking`. En los modelos actuales, el pensamiento es adaptativo: Claude determina cuándo y con qué profundidad pensar, y en los modelos Claude 5 está activado de forma predeterminada; el "extended thinking" (pensamiento extendido) configurado manualmente es un modo heredado. Aunque el pensamiento mejora el razonamiento de Claude en tareas complejas, el SDK de OpenAI no devuelve el pensamiento de Claude. Para obtener todas las funciones de pensamiento, incluido el [pensamiento resumido](https://platform.claude.com/docs/es/build-with-claude/thinking#summarized-thinking), usa la Claude API nativa.
```python Python
response = client.chat.completions.create(
model="claude-sonnet-4-6",
messages=[{"role": "user", "content": "Who are you?"}],
extra_body={"thinking": {"type": "enabled", "budget_tokens": 2000}},
)
```
```typescript TypeScript
const response = await openai.chat.completions.create({
messages: [{ role: "user", content: "Who are you?" }],
model: "claude-sonnet-4-6",
// @ts-expect-error
thinking: { type: "enabled", budget_tokens: 2000 }
});
```
```csharp C#
// El SDK de .NET no tiene un parámetro extra_body como el de Python, así que este ejemplo
// envía el parámetro thinking con el método de protocolo documentado del SDK
// (un cuerpo de solicitud JSON sin procesar).
BinaryData input = BinaryData.FromString("""
{
"model": "claude-sonnet-4-6",
"messages": [{ "role": "user", "content": "Who are you?" }],
"thinking": { "type": "enabled", "budget_tokens": 2000 }
}
""");
using BinaryContent content = BinaryContent.Create(input);
ClientResult result = chatClient.CompleteChat(content);
```
```go Go
response, err := client.Chat.Completions.New(
context.Background(),
openai.ChatCompletionNewParams{
Model: "claude-sonnet-4-6",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Who are you?"),
},
},
option.WithJSONSet("thinking", map[string]any{"type": "enabled", "budget_tokens": 2000}),
)
```
```java Java
ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
.model("claude-sonnet-4-6")
.addUserMessage("Who are you?")
.putAdditionalBodyProperty("thinking",
JsonValue.from(Map.of("type", "enabled", "budget_tokens", 2000)))
.build();
ChatCompletion completion = client.chat().completions().create(params);
```
OpenAI no tiene un SDK oficial para PHP. Para usar Claude desde PHP, usa en su lugar el [SDK de Claude para PHP](https://platform.claude.com/docs/es/cli-sdks-libraries/sdks/php).
```ruby Ruby
response = openai.chat.completions.create(
model: "claude-sonnet-4-6",
messages: [{role: "user", content: "Who are you?"}],
request_options: {extra_body: {thinking: {type: "enabled", budget_tokens: 2000}}}
)
```
## Límites de velocidad
Los "rate limits" (límites de velocidad) siguen los [límites estándar](https://platform.claude.com/docs/es/api/rate-limits) de Anthropic para el endpoint `/v1/messages`.
## Compatibilidad detallada con la API compatible con OpenAI
### Campos de solicitud
#### Campos simples
| Campo | Estado de compatibilidad |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `model` | Usa nombres de modelos Claude |
| `max_tokens` | Totalmente compatible |
| `max_completion_tokens` | Totalmente compatible |
| `stream` | Totalmente compatible |
| `stream_options` | Totalmente compatible |
| `top_p` | Se pasa al modelo. Los modelos Claude 4.7 y posteriores y Claude Mythos Preview devuelven un error 400 para cualquier valor distinto de `0.99`, el predeterminado, así que omítelo. Una solicitud que establece tanto `temperature` como `top_p` también devuelve un error 400. Consulta [Trabajar con mensajes](https://platform.claude.com/docs/es/build-with-claude/working-with-messages). |
| `parallel_tool_calls` | Totalmente compatible |
| `stop` | Todas las secuencias de parada que no sean espacios en blanco funcionan |
| `temperature` | Entre 0 y 1 (inclusive). Los valores mayores que 1 se limitan a 1. En los modelos Claude 4.7 y posteriores y Claude Mythos Preview, cualquier valor inferior a 1 devuelve un error 400, así que omítelo. Consulta [Trabajar con mensajes](https://platform.claude.com/docs/es/build-with-claude/working-with-messages). |
| `n` | Debe ser exactamente 1 |
| `logprobs` | Ignorado |
| `metadata` | Ignorado |
| `response_format` | Ignorado. Para salida JSON, usa [Structured Outputs](https://platform.claude.com/docs/es/build-with-claude/structured-outputs) con la Claude API nativa |
| `prediction` | Ignorado |
| `presence_penalty` | Ignorado |
| `frequency_penalty` | Ignorado |
| `seed` | Ignorado |
| `service_tier` | Ignorado |
| `audio` | Ignorado |
| `logit_bias` | Ignorado |
| `store` | Ignorado |
| `user` | Ignorado |
| `modalities` | Ignorado |
| `top_logprobs` | Ignorado |
| `reasoning_effort` | Ignorado |
#### Campos `tools` / `functions`
Campos `tools[n].function`
| Campo | Estado de compatibilidad |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name` | Totalmente compatible |
| `description` | Totalmente compatible |
| `parameters` | Totalmente compatible |
| `strict` | Ignorado. Usa [Structured Outputs](https://platform.claude.com/docs/es/build-with-claude/structured-outputs) con la Claude API nativa para una validación estricta del esquema |
Campos `functions[n]`
OpenAI ha dejado obsoleto el campo `functions` y sugiere usar `tools` en su lugar.
| Campo | Estado de compatibilidad |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name` | Totalmente compatible |
| `description` | Totalmente compatible |
| `parameters` | Totalmente compatible |
| `strict` | Ignorado. Usa [Structured Outputs](https://platform.claude.com/docs/es/build-with-claude/structured-outputs) con la Claude API nativa para una validación estricta del esquema |
#### Campos del array `messages`
Campos para `messages[n].role == "developer"`
Los mensajes de desarrollador se elevan al principio de la conversación como parte del mensaje de sistema inicial
| Campo | Estado de compatibilidad |
| --------- | ----------------------------------- |
| `content` | Totalmente compatible, pero elevado |
| `name` | Ignorado |
Campos para `messages[n].role == "system"`
Los mensajes de sistema se elevan al principio de la conversación como parte del mensaje de sistema inicial
| Campo | Estado de compatibilidad |
| --------- | ----------------------------------- |
| `content` | Totalmente compatible, pero elevado |
| `name` | Ignorado |
Campos para `messages[n].role == "user"`
| Campo | Variante | Subcampo | Estado de compatibilidad |
| --------- | -------------------------------- | -------- | ------------------------ |
| `content` | `string` | | Totalmente compatible |
| | `array`, `type == "text"` | | Totalmente compatible |
| | `array`, `type == "image_url"` | `url` | Totalmente compatible |
| | | `detail` | Ignorado |
| | `array`, `type == "input_audio"` | | Ignorado |
| | `array`, `type == "file"` | | Ignorado |
| `name` | | | Ignorado |
Campos para `messages[n].role == "assistant"`
| Campo | Variante | Estado de compatibilidad |
| --------------- | ---------------------------- | ------------------------ |
| `content` | `string` | Totalmente compatible |
| | `array`, `type == "text"` | Totalmente compatible |
| | `array`, `type == "refusal"` | Ignorado |
| `tool_calls` | | Totalmente compatible |
| `function_call` | | Totalmente compatible |
| `audio` | | Ignorado |
| `refusal` | | Ignorado |
Campos para `messages[n].role == "tool"`
| Campo | Variante | Estado de compatibilidad |
| -------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `content` | `string` | Totalmente compatible |
| | `array`, `type == "text"` | Totalmente compatible |
| `tool_call_id` | | Totalmente compatible |
| `tool_choice` | | Compatible. Los valores `"required"` y de función con nombre fuerzan una llamada a herramienta; Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 y Claude Mythos 5.1 no admiten el uso forzado de herramientas y devuelven un error, así que usa `"auto"` en esos modelos. Consulta [Forzar el uso de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/define-tools#forcing-tool-use). |
| `name` | | Ignorado |
Campos para `messages[n].role == "function"`
| Campo | Variante | Estado de compatibilidad |
| ------------- | ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `content` | `string` | Totalmente compatible |
| | `array`, `type == "text"` | Totalmente compatible |
| `tool_choice` | | Compatible. Los valores `"required"` y de función con nombre fuerzan una llamada a herramienta; Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 y Claude Mythos 5.1 no admiten el uso forzado de herramientas y devuelven un error, así que usa `"auto"` en esos modelos. Consulta [Forzar el uso de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/define-tools#forcing-tool-use). |
| `name` | | Ignorado |
### Campos de respuesta
| Campo | Estado de compatibilidad |
| --------------------------------- | -------------------------------- |
| `id` | Totalmente compatible |
| `choices[]` | Siempre tendrá una longitud de 1 |
| `choices[].finish_reason` | Totalmente compatible |
| `choices[].index` | Totalmente compatible |
| `choices[].message.role` | Totalmente compatible |
| `choices[].message.content` | Totalmente compatible |
| `choices[].message.tool_calls` | Totalmente compatible |
| `object` | Totalmente compatible |
| `created` | Totalmente compatible |
| `model` | Totalmente compatible |
| `finish_reason` | Totalmente compatible |
| `content` | Totalmente compatible |
| `usage.completion_tokens` | Totalmente compatible |
| `usage.prompt_tokens` | Totalmente compatible |
| `usage.total_tokens` | Totalmente compatible |
| `usage.completion_tokens_details` | Siempre vacío |
| `usage.prompt_tokens_details` | Siempre vacío |
| `choices[].message.refusal` | Siempre vacío |
| `choices[].message.audio` | Siempre vacío |
| `logprobs` | Siempre vacío |
| `service_tier` | Siempre vacío |
| `system_fingerprint` | Siempre vacío |
### Compatibilidad de mensajes de error
La capa de compatibilidad mantiene formatos de error coherentes con la API de OpenAI. Sin embargo, los mensajes de error detallados no serán equivalentes. Usa los mensajes de error únicamente para registro y depuración.
### Compatibilidad de encabezados
Aunque el SDK de OpenAI gestiona los encabezados automáticamente, esta es la lista completa de encabezados compatibles con la Claude API para los desarrolladores que necesiten trabajar con ellos directamente.
| Encabezado | Estado de compatibilidad |
| -------------------------------- | ------------------------ |
| `x-ratelimit-limit-requests` | Totalmente compatible |
| `x-ratelimit-limit-tokens` | Totalmente compatible |
| `x-ratelimit-remaining-requests` | Totalmente compatible |
| `x-ratelimit-remaining-tokens` | Totalmente compatible |
| `x-ratelimit-reset-requests` | Totalmente compatible |
| `x-ratelimit-reset-tokens` | Totalmente compatible |
| `retry-after` | Totalmente compatible |
| `request-id` | Totalmente compatible |
| `openai-version` | Siempre `2020-10-01` |
| `authorization` | Totalmente compatible |
| `openai-processing-ms` | Siempre vacío |