---
title: Compatibilità con l'SDK OpenAI
url: https://platform.claude.com/docs/it/cli-sdks-libraries/libraries/openai-sdk
description: Anthropic fornisce un livello di compatibilità che ti consente di utilizzare l'SDK OpenAI per testare la Claude API. Con poche modifiche al codice, puoi valutare rapidamente le capacità dei modelli Anthropic.
---
Questo livello di compatibilità è destinato principalmente a testare e confrontare le capacità dei modelli e non è considerato una soluzione a lungo termine o pronta per la produzione per la maggior parte dei casi d'uso. Sebbene sia previsto che rimanga pienamente funzionante e non subisca modifiche incompatibili, la priorità è l'affidabilità e l'efficacia della [Claude API](https://platform.claude.com/docs/it/api/overview).
Per maggiori informazioni sulle limitazioni di compatibilità note, consulta [Limitazioni importanti della compatibilità OpenAI](https://platform.claude.com/docs/it/cli-sdks-libraries/libraries/openai-sdk#important-openai-compatibility-limitations).
Se riscontri problemi con la funzionalità di compatibilità con l'SDK OpenAI, condividi il tuo feedback tramite questo [modulo di feedback sulla compatibilità](https://forms.gle/oQV4McQNiuuNbz9n8).
Per la migliore esperienza e l'accesso al set completo di funzionalità della Claude API ([elaborazione PDF](https://platform.claude.com/docs/it/build-with-claude/pdf-support), [citazioni](https://platform.claude.com/docs/it/build-with-claude/citations), [thinking](https://platform.claude.com/docs/it/build-with-claude/thinking) e ["prompt caching" (cache dei prompt)](https://platform.claude.com/docs/it/build-with-claude/prompt-caching)), usa la [Claude API](https://platform.claude.com/docs/it/api/overview) nativa.
## Iniziare con l'SDK OpenAI
Per utilizzare la funzionalità di compatibilità con l'SDK OpenAI, dovrai:
1. Usare un SDK OpenAI ufficiale
2. Modificare quanto segue
* Aggiorna il tuo URL di base in modo che punti alla Claude API
* Sostituisci la tua "API key" (chiave API) con una [chiave API Claude](https://platform.claude.com/settings/keys)
* Se la tua chiave è una [chiave personale o di account di servizio](https://platform.claude.com/docs/it/manage-claude/authentication#key-types) con accesso a più workspace, invia anche l'header `anthropic-workspace-id` in ogni richiesta (ad esempio, `default_headers` nell'SDK Python o `defaultHeaders` in TypeScript); consulta [Selezionare un workspace](https://platform.claude.com/docs/it/manage-claude/authentication#select-a-workspace)
* Aggiorna il nome del modello per utilizzare un [modello Claude](https://platform.claude.com/docs/it/models/overview)
3. Consultare le sezioni seguenti per sapere quali funzionalità sono supportate
### Esempio di avvio rapido
```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 non dispone di un SDK PHP ufficiale. Per usare Claude da PHP, usa invece l'[SDK Claude per PHP](https://platform.claude.com/docs/it/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
```
## Limitazioni importanti della compatibilità OpenAI
### Comportamento dell'API
Ecco le differenze più sostanziali rispetto all'utilizzo di OpenAI:
* Il parametro `strict` per il function calling viene ignorato, il che significa che non è garantito che il JSON del "tool use" (uso degli strumenti) segua lo schema fornito. Per una conformità garantita allo schema, usa la [Claude API nativa con Structured Outputs](https://platform.claude.com/docs/it/build-with-claude/structured-outputs).
* L'input audio non è supportato; verrà ignorato e rimosso dall'input
* La cache dei prompt non è supportata, ma è supportata negli [SDK Anthropic](https://platform.claude.com/docs/it/cli-sdks-libraries/overview)
* I messaggi system/developer vengono spostati in cima e concatenati nel campo `system` di primo livello, ovunque compaiano nella conversazione. Per aggiungere istruzioni di sistema a metà di una conversazione, usa i [messaggi di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages) nella Claude API nativa.
La maggior parte dei campi non supportati viene ignorata silenziosamente anziché produrre errori. Sono tutti documentati nelle sezioni seguenti.
### Considerazioni sulla qualità dell'output
Se hai apportato molte modifiche al tuo prompt, è probabile che sia ottimizzato specificamente per OpenAI. Valuta di rielaborarlo per Claude utilizzando la [guida alle best practice di prompting](https://platform.claude.com/docs/it/build-with-claude/prompt-engineering/claude-prompting-best-practices).
### Spostamento dei messaggi system / developer
La maggior parte degli input dell'SDK OpenAI corrisponde chiaramente e direttamente ai parametri dell'API di Anthropic, ma una differenza evidente è la gestione dei prompt system / developer. Con OpenAI, questi due tipi di prompt possono essere inseriti in qualsiasi punto di una conversazione chat. Il livello di compatibilità prende tutti i messaggi system/developer e li concatena con un singolo carattere di nuova riga (`\n`) tra di essi. Questa stringa completa viene quindi fornita come campo `system` di primo livello, prima di ogni messaggio.
### Supporto al thinking
Puoi abilitare il [ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking) aggiungendo il parametro `thinking`. Sui modelli attuali il ragionamento è adattivo, con Claude che determina quando e quanto a fondo ragionare, e sui modelli Claude 5 è attivo per impostazione predefinita; il ragionamento esteso configurato manualmente è una modalità legacy. Sebbene il ragionamento migliori le capacità di Claude nei compiti complessi, l'SDK OpenAI non restituisce il ragionamento di Claude. Per le funzionalità complete di ragionamento, incluso il [ragionamento riassunto](https://platform.claude.com/docs/it/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#
// L'SDK .NET non ha un parametro extra_body come quello di Python, quindi questo esempio
// invia il parametro thinking con il metodo di protocollo documentato dell'SDK
// (un corpo di richiesta JSON grezzo).
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 non dispone di un SDK PHP ufficiale. Per usare Claude da PHP, usa invece l'[SDK Claude per PHP](https://platform.claude.com/docs/it/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}}}
)
```
## Limiti di velocità
I "rate limits" (limiti di velocità) seguono i [limiti standard](https://platform.claude.com/docs/it/api/rate-limits) di Anthropic per l'endpoint `/v1/messages`.
## Supporto dettagliato dell'API compatibile con OpenAI
### Campi della richiesta
#### Campi semplici
| Campo | Stato del supporto |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `model` | Usa i nomi dei modelli Claude |
| `max_tokens` | Pienamente supportato |
| `max_completion_tokens` | Pienamente supportato |
| `stream` | Pienamente supportato |
| `stream_options` | Pienamente supportato |
| `top_p` | Passato al modello. I modelli Claude 4.7 e successivi e Claude Mythos Preview restituiscono un errore 400 per qualsiasi valore diverso da `0.99`, il valore predefinito, quindi omettilo. Anche una richiesta che imposta sia `temperature` sia `top_p` restituisce un errore 400. Consulta [Utilizzo della Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages). |
| `parallel_tool_calls` | Pienamente supportato |
| `stop` | Tutte le sequenze di stop non composte da spazi bianchi funzionano |
| `temperature` | Tra 0 e 1 (inclusi). I valori maggiori di 1 vengono limitati a 1. Sui modelli Claude 4.7 e successivi e su Claude Mythos Preview, qualsiasi valore inferiore a 1 restituisce un errore 400, quindi omettilo. Consulta [Utilizzo della Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages). |
| `n` | Deve essere esattamente 1 |
| `logprobs` | Ignorato |
| `metadata` | Ignorato |
| `response_format` | Ignorato. Per l'output JSON, usa [Structured Outputs](https://platform.claude.com/docs/it/build-with-claude/structured-outputs) con la Claude API nativa |
| `prediction` | Ignorato |
| `presence_penalty` | Ignorato |
| `frequency_penalty` | Ignorato |
| `seed` | Ignorato |
| `service_tier` | Ignorato |
| `audio` | Ignorato |
| `logit_bias` | Ignorato |
| `store` | Ignorato |
| `user` | Ignorato |
| `modalities` | Ignorato |
| `top_logprobs` | Ignorato |
| `reasoning_effort` | Ignorato |
#### Campi `tools` / `functions`
Campi `tools[n].function`
| Campo | Stato del supporto |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name` | Pienamente supportato |
| `description` | Pienamente supportato |
| `parameters` | Pienamente supportato |
| `strict` | Ignorato. Usa [Structured Outputs](https://platform.claude.com/docs/it/build-with-claude/structured-outputs) con la Claude API nativa per una validazione rigorosa dello schema |
Campi `functions[n]`
OpenAI ha deprecato il campo `functions` e suggerisce di utilizzare `tools` al suo posto.
| Campo | Stato del supporto |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name` | Pienamente supportato |
| `description` | Pienamente supportato |
| `parameters` | Pienamente supportato |
| `strict` | Ignorato. Usa [Structured Outputs](https://platform.claude.com/docs/it/build-with-claude/structured-outputs) con la Claude API nativa per una validazione rigorosa dello schema |
#### Campi dell'array `messages`
Campi per `messages[n].role == "developer"`
I messaggi developer vengono spostati all'inizio della conversazione come parte del messaggio di sistema iniziale
| Campo | Stato del supporto |
| --------- | ---------------------------------- |
| `content` | Pienamente supportato, ma spostato |
| `name` | Ignorato |
Campi per `messages[n].role == "system"`
I messaggi system vengono spostati all'inizio della conversazione come parte del messaggio di sistema iniziale
| Campo | Stato del supporto |
| --------- | ---------------------------------- |
| `content` | Pienamente supportato, ma spostato |
| `name` | Ignorato |
Campi per `messages[n].role == "user"`
| Campo | Variante | Sotto-campo | Stato del supporto |
| --------- | -------------------------------- | ----------- | --------------------- |
| `content` | `string` | | Pienamente supportato |
| | `array`, `type == "text"` | | Pienamente supportato |
| | `array`, `type == "image_url"` | `url` | Pienamente supportato |
| | | `detail` | Ignorato |
| | `array`, `type == "input_audio"` | | Ignorato |
| | `array`, `type == "file"` | | Ignorato |
| `name` | | | Ignorato |
Campi per `messages[n].role == "assistant"`
| Campo | Variante | Stato del supporto |
| --------------- | ---------------------------- | --------------------- |
| `content` | `string` | Pienamente supportato |
| | `array`, `type == "text"` | Pienamente supportato |
| | `array`, `type == "refusal"` | Ignorato |
| `tool_calls` | | Pienamente supportato |
| `function_call` | | Pienamente supportato |
| `audio` | | Ignorato |
| `refusal` | | Ignorato |
Campi per `messages[n].role == "tool"`
| Campo | Variante | Stato del supporto |
| -------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `content` | `string` | Pienamente supportato |
| | `array`, `type == "text"` | Pienamente supportato |
| `tool_call_id` | | Pienamente supportato |
| `tool_choice` | | Supportato. I valori `"required"` e quelli con funzione nominata forzano una chiamata a uno strumento; Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 e Claude Mythos 5.1 non supportano l'uso forzato degli strumenti e restituiscono un errore, quindi usa `"auto"` su questi modelli. Consulta [Forzare l'uso degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/define-tools#forcing-tool-use). |
| `name` | | Ignorato |
Campi per `messages[n].role == "function"`
| Campo | Variante | Stato del supporto |
| ------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `content` | `string` | Pienamente supportato |
| | `array`, `type == "text"` | Pienamente supportato |
| `tool_choice` | | Supportato. I valori `"required"` e quelli con funzione nominata forzano una chiamata a uno strumento; Claude Opus 5.5, Claude Sonnet 5.5, Claude Fable 5.1 e Claude Mythos 5.1 non supportano l'uso forzato degli strumenti e restituiscono un errore, quindi usa `"auto"` su questi modelli. Consulta [Forzare l'uso degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/define-tools#forcing-tool-use). |
| `name` | | Ignorato |
### Campi della risposta
| Campo | Stato del supporto |
| --------------------------------- | ---------------------------------- |
| `id` | Pienamente supportato |
| `choices[]` | Avrà sempre una lunghezza pari a 1 |
| `choices[].finish_reason` | Pienamente supportato |
| `choices[].index` | Pienamente supportato |
| `choices[].message.role` | Pienamente supportato |
| `choices[].message.content` | Pienamente supportato |
| `choices[].message.tool_calls` | Pienamente supportato |
| `object` | Pienamente supportato |
| `created` | Pienamente supportato |
| `model` | Pienamente supportato |
| `finish_reason` | Pienamente supportato |
| `content` | Pienamente supportato |
| `usage.completion_tokens` | Pienamente supportato |
| `usage.prompt_tokens` | Pienamente supportato |
| `usage.total_tokens` | Pienamente supportato |
| `usage.completion_tokens_details` | Sempre vuoto |
| `usage.prompt_tokens_details` | Sempre vuoto |
| `choices[].message.refusal` | Sempre vuoto |
| `choices[].message.audio` | Sempre vuoto |
| `logprobs` | Sempre vuoto |
| `service_tier` | Sempre vuoto |
| `system_fingerprint` | Sempre vuoto |
### Compatibilità dei messaggi di errore
Il livello di compatibilità mantiene formati di errore coerenti con l'API OpenAI. Tuttavia, i messaggi di errore dettagliati non saranno equivalenti. Usa i messaggi di errore solo per il logging e il debugging.
### Compatibilità degli header
Sebbene l'SDK OpenAI gestisca automaticamente gli header, ecco l'elenco completo degli header supportati dalla Claude API per gli sviluppatori che hanno bisogno di lavorarci direttamente.
| Header | Stato del supporto |
| -------------------------------- | --------------------- |
| `x-ratelimit-limit-requests` | Pienamente supportato |
| `x-ratelimit-limit-tokens` | Pienamente supportato |
| `x-ratelimit-remaining-requests` | Pienamente supportato |
| `x-ratelimit-remaining-tokens` | Pienamente supportato |
| `x-ratelimit-reset-requests` | Pienamente supportato |
| `x-ratelimit-reset-tokens` | Pienamente supportato |
| `retry-after` | Pienamente supportato |
| `request-id` | Pienamente supportato |
| `openai-version` | Sempre `2020-10-01` |
| `authorization` | Pienamente supportato |
| `openai-processing-ms` | Sempre vuoto |