---
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 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 completamente funzionante e senza modifiche che causano incompatibilità, 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 all'intero set 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), [ragionamento](https://platform.claude.com/docs/it/build-with-claude/thinking) e [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, devi:
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 chiave API con una [chiave API di Claude](https://platform.claude.com/settings/keys) dalla Claude Console.
* Se la tua chiave è una [chiave personale o di account di servizio](https://platform.claude.com/docs/it/manage-claude/authentication#key-types) non associata a un 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 usare un [modello Claude](https://platform.claude.com/docs/it/models/overview).
3. Consultare le sezioni seguenti per scoprire 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 il JSON dell'uso degli strumenti non è garantito che segua lo schema fornito. Per una conformità garantita allo schema, usa la [Claude API nativa con output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs).
* L'input audio non è supportato; viene 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 modificato ampiamente il tuo prompt, è probabile che sia ottimizzato specificamente per OpenAI. Valuta di rielaborarlo per Claude utilizzando la guida sulle [best practice per i prompt](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 direttamente ai parametri della Claude API, ma una differenza evidente è la gestione dei prompt di sistema / sviluppatore. Questi due tipi di prompt possono essere inseriti in qualsiasi punto di una conversazione chat nell'API OpenAI. Il livello di compatibilità prende tutti i messaggi di sistema/sviluppatore e li concatena con un singolo carattere di nuova riga (`\n`) tra di loro. Questa stringa completa viene quindi fornita come campo di primo livello `system`, 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 gli [output strutturati](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 gli [output strutturati](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 consiglia di usare invece `tools`.
| Campo | Stato del supporto |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name` | Pienamente supportato |
| `description` | Pienamente supportato |
| `parameters` | Pienamente supportato |
| `strict` | Ignorato. Usa gli [output strutturati](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 dello sviluppatore 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 di sistema 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[]` | Ha sempre lunghezza 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 sono equivalenti. Usa i messaggi di errore solo per il logging e il debug.
### 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 devono 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 |