> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Inizia con CometAPI: crea una chiave API ed effettua la tua prima chiamata

> Inizia con CometAPI creando una chiave API, impostando la base URL e inviando la tua prima richiesta API con curl, Python o Node.js.

## Crea un account e una chiave API

Crea un account CometAPI e una chiave API prima di chiamare l'API.

<Steps>
  <Step title="Accedi o crea un account">
    Apri la [pagina di accesso di CometAPI](https://www.cometapi.com/console/login). Continua con Google, continua con GitHub oppure inserisci la tua email o il nome utente. Se non hai un account, completa la creazione dell'account da questa pagina.

    <Frame>
      <img src="https://mintcdn.com/cometapi/BtE3Lagaukxd3efj/images/overview/cometapi-console-login.png?fit=max&auto=format&n=BtE3Lagaukxd3efj&q=85&s=988bee0055bf1ce2552a8d877a48a97d" alt="Pagina di accesso di CometAPI con opzioni di accesso tramite Google, GitHub ed email" width="1280" height="720" data-path="images/overview/cometapi-console-login.png" />
    </Frame>
  </Step>

  <Step title="Apri le chiavi API">
    Dopo aver effettuato l'accesso, apri la [pagina delle chiavi API](https://www.cometapi.com/console/token). Puoi anche selezionare **API Keys** nella barra laterale della dashboard.
  </Step>

  <Step title="Crea una chiave API">
    Fai clic su **Create API Key**, inserisci un nome chiaro come `local-test` e lascia **Unlimited Quota** abilitato per un primo test, a meno che tu non voglia impostare un limite di spesa. Fai clic su **Create**.

    <Frame>
      <img src="https://mintcdn.com/cometapi/SZhlxZhCnMLn__BW/images/overview/810968_364191.png?fit=max&auto=format&n=SZhlxZhCnMLn__BW&q=85&s=aef81a83f29f8eb16655ed4060425f50" alt="Pagina delle chiavi API di CometAPI con il pulsante Create API Key e la finestra di creazione evidenziati" width="3824" height="1892" data-path="images/overview/810968_364191.png" />
    </Frame>
  </Step>

  <Step title="Copia la chiave API">
    Fai clic sul pulsante di copia nella colonna **Key**. Salva la chiave copiata in una variabile d'ambiente lato server o in un file `.env` locale. Non incollare una chiave API reale in repository pubblici, codice frontend, screenshot o ticket di supporto.

    <Frame>
      <img src="https://mintcdn.com/cometapi/HhtmQffktazbxUvS/images/overview/810968_364193.png?fit=max&auto=format&n=HhtmQffktazbxUvS&q=85&s=d893f659267150d0faf45f99eb5dffc1" alt="Tabella delle chiavi API di CometAPI con il pulsante di copia evidenziato per una chiave API mascherata" width="2434" height="1232" data-path="images/overview/810968_364193.png" />
    </Frame>
  </Step>
</Steps>

Gli esempi di richiesta leggono `COMETAPI_KEY` dal tuo ambiente.

## Salva la tua chiave API in locale

Per i test locali, esporta la tua chiave API come variabile d'ambiente:

```bash theme={null}
read -rsp "CometAPI API key: " COMETAPI_KEY
printf '\n'
export COMETAPI_KEY
```

## Base URL

Usa questa base URL per gli SDK compatibili con OpenAI e per le chiamate API:

```text theme={null}
https://api.cometapi.com/v1
```

## Passa da OpenAI in 30 secondi

Dopo aver ottenuto una chiave API CometAPI, usa questa modifica di due impostazioni quando passi un client SDK OpenAI a CometAPI:

```diff theme={null}
- base_url="https://api.openai.com/v1"
- api_key=os.environ["OPENAI_API_KEY"]
+ base_url="https://api.cometapi.com/v1"
+ api_key=os.environ["COMETAPI_KEY"]
```

CometAPI usa formati di richiesta compatibili con OpenAI per i comuni flussi di lavoro di testo, immagini, audio e video. Se la tua app usa già l'SDK OpenAI, inizia modificando la base URL e la chiave API.

## Effettua la tua prima chiamata

Dopo aver impostato `COMETAPI_KEY` nel tuo ambiente, sostituisci `your-model-id` con un model ID attuale dalla [pagina Models](/it/overview/models).

<CodeGroup>
  ```bash cURL theme={null}
  curl https://api.cometapi.com/v1/chat/completions \
    -H "Authorization: Bearer $COMETAPI_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "your-model-id",
      "messages": [
        {
          "role": "user",
          "content": "Write a one-sentence bedtime story."
        }
      ]
    }'
  ```

  ```python Python theme={null}
  import os
  from openai import OpenAI

  client = OpenAI(
      api_key=os.environ["COMETAPI_KEY"],
      base_url="https://api.cometapi.com/v1",
  )

  completion = client.chat.completions.create(
      model="your-model-id",
      messages=[
          {
              "role": "user",
              "content": "Write a one-sentence bedtime story.",
          }
      ],
  )

  print(completion.choices[0].message.content)
  ```

  ```javascript Node.js theme={null}
  import OpenAI from "openai";

  const client = new OpenAI({
    apiKey: process.env.COMETAPI_KEY,
    baseURL: "https://api.cometapi.com/v1",
  });

  const completion = await client.chat.completions.create({
    model: "your-model-id",
    messages: [
      {
        role: "user",
        content: "Write a one-sentence bedtime story.",
      },
    ],
  });

  console.log(completion.choices[0].message.content);
  ```
</CodeGroup>

## Scegli un modello

Scegli un model ID dalla [pagina Models](/it/overview/models), quindi passa quel valore nel campo `model`.

| Obiettivo               | Da dove iniziare                                                                                                                              |
| ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| Chat o testo generale   | Usa un modello GPT, Claude, Gemini, DeepSeek o un altro modello di chat con [Chat Completions](/api/text/chat).                               |
| Coding e ragionamento   | Usa un modello per coding o ragionamento con [Responses](/api/text/responses) quando il modello richiede l'API Responses.                     |
| Generazione di immagini | Usa un modello di immagini con [Create image](/api/image/openai/images) o una guida alle immagini specifica del provider.                     |
| Generazione video       | Usa un modello video con la pagina API video che corrisponde al flusso di lavoro del provider, come [Create video](/api/video/sora-2/create). |

## Qual è il prossimo passo

* Per gli errori nelle richieste, consulta [Error Codes & Handling](/it/errors/error-codes-handling).
* Per indicazioni sui retry, consulta [how to handle rate limits](/api/text/chat#how-to-handle-rate-limits).
* Per l'utilizzo specifico del modello, inizia con [Chat Completions](/api/text/chat), [Responses](/api/text/responses), [Create image](/api/image/openai/images) o [Create video](/api/video/sora-2/create).
* Per i dettagli sulla fatturazione, consulta [About Pricing](/it/pricing/about-pricing).
* Per invitare membri del team e gestire i crediti condivisi, consulta [Gestire un team con Workspace](/it/workspace/overview).
* Per assistenza, consulta il [Help Center](/it/support/help-center) o contatta il [supporto CometAPI](https://www.cometapi.com/support/).

## FAQ

<AccordionGroup>
  <Accordion title="Come faccio a creare un account CometAPI?">
    Apri la [pagina di accesso di CometAPI](https://www.cometapi.com/console/login), quindi continua con Google, continua con GitHub oppure inserisci la tua email o il tuo nome utente. Se non hai un account, completa la creazione dell'account dalla stessa pagina.
  </Accordion>

  <Accordion title="Come ottengo una chiave API di CometAPI?">
    Apri la [pagina delle chiavi API](https://www.cometapi.com/console/token) nella dashboard di CometAPI, fai clic su **Create API Key**, inserisci un nome, fai clic su **Create** e copia la chiave API generata. Usa `$COMETAPI_KEY` negli esempi al posto di una chiave API reale.
  </Accordion>

  <Accordion title="Dove dovrei archiviare la mia chiave API?">
    Archivia la tua chiave API in una variabile d'ambiente lato server o in un file locale `.env`. Non eseguirne il commit in repository pubblici, non incollarla nel codice frontend, non includerla negli screenshot e non inviarla nei ticket di supporto.
  </Accordion>

  <Accordion title="Qual è il base URL di CometAPI per le chiamate API?">
    Usa `https://api.cometapi.com/v1` per gli SDK compatibili con OpenAI e gli endpoint come `/v1/chat/completions`.
  </Accordion>

  <Accordion title="CometAPI funziona con l'SDK Python di OpenAI?">
    Sì. Crea un client `OpenAI`, imposta `api_key` sulla tua chiave API di CometAPI e imposta `base_url` su `https://api.cometapi.com/v1`.
  </Accordion>

  <Accordion title="Come faccio a passare da OpenAI a CometAPI?">
    Modifica il base URL in `https://api.cometapi.com/v1`, sostituisci la chiave API con la tua chiave API di CometAPI e usa un model ID di CometAPI dalla [pagina Models](/it/overview/models).
  </Accordion>

  <Accordion title="Quale model ID dovrei usare per primo?">
    Scegli il model ID in base al caso d'uso. Parti dalla [pagina Models](/it/overview/models), quindi seleziona un modello chat, coding, image o video che corrisponda alla pagina API che intendi chiamare.
  </Accordion>

  <Accordion title="Quali linguaggi di programmazione supporta CometAPI?">
    CometAPI funziona con qualsiasi linguaggio di programmazione in grado di inviare richieste HTTPS. Inizia con gli esempi curl, Python e Node.js in questa pagina, oppure usa un SDK compatibile con OpenAI che ti consenta di sovrascrivere il base URL.
  </Accordion>

  <Accordion title="CometAPI offre una prova gratuita o una chiave API gratuita?">
    Puoi creare una chiave API di CometAPI dalla dashboard. Per verificare la disponibilità della prova gratuita, i crediti della prova gratuita e i dettagli di fatturazione, consulta la [pagina dei prezzi di CometAPI](https://www.cometapi.com/pricing/) e [Informazioni sui prezzi](/it/pricing/about-pricing).
  </Accordion>
</AccordionGroup>

<script type="application/ld+json">
  {`
    {
    "@context": "https://schema.org",
    "@graph": [
      {
        "@type": "HowTo",
        "name": "Guida rapida a CometAPI: crea una chiave API ed effettua la tua prima chiamata",
        "description": "Guida rapida a CometAPI per chi lo usa per la prima volta: accedi, crea una chiave API, copia la chiave, imposta il base URL ed effettua la tua prima chiamata API con curl, Python o Node.js.",
        "step": [
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/overview/quick-start#sign-in-or-create-an-account",
            "name": "Accedi o crea un account",
            "text": "Apri https://www.cometapi.com/console/login e continua con Google, GitHub o email."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/overview/quick-start#open-api-keys",
            "name": "Apri le chiavi API",
            "text": "Dopo aver effettuato l'accesso, apri https://www.cometapi.com/console/token oppure seleziona API Keys nella barra laterale della dashboard."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/overview/quick-start#create-an-api-key",
            "name": "Crea una chiave API",
            "text": "Fai clic su Create API Key, inserisci un nome, scegli l'impostazione della quota e fai clic su Create."
          },
          {
            "@type": "HowToStep",
            "@id": "https://apidoc.cometapi.com/overview/quick-start#copy-the-api-key",
            "name": "Copia la chiave API",
            "text": "Fai clic sul pulsante di copia nella colonna Key e archivia la chiave in una variabile d'ambiente lato server o in un file locale .env."
          },
          {
            "@type": "HowToStep",
            "name": "Imposta il base URL",
            "text": "Usa https://api.cometapi.com/v1 come base URL per gli SDK compatibili con OpenAI e le chiamate API."
          },
          {
            "@type": "HowToStep",
            "name": "Effettua la tua prima chiamata",
            "text": "Chiama /v1/chat/completions con curl, Python o Node.js e sostituisci your-model-id con un model ID corrente dalla pagina Models di CometAPI."
          }
        ]
      },
      {
        "@type": "FAQPage",
        "mainEntity": [
          {
            "@type": "Question",
            "name": "Come faccio a creare un account CometAPI?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Apri la pagina di accesso di CometAPI e continua con Google, GitHub o email. Se non hai un account, completa la creazione dell'account dalla stessa pagina."
            }
          },
          {
            "@type": "Question",
            "name": "Come ottengo una chiave API di CometAPI?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Apri la pagina delle chiavi API nella dashboard di CometAPI, fai clic su Create API Key, inserisci un nome, fai clic su Create e copia la chiave API generata."
            }
          },
          {
            "@type": "Question",
            "name": "Dove dovrei archiviare la mia chiave API?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Archivia la tua chiave API in una variabile d'ambiente lato server o in un file locale .env. Non eseguirne il commit in repository pubblici, non incollarla nel codice frontend, non includerla negli screenshot e non inviarla nei ticket di supporto."
            }
          },
          {
            "@type": "Question",
            "name": "Qual è il base URL di CometAPI per le chiamate API?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Usa https://api.cometapi.com/v1 per gli SDK e gli endpoint compatibili con OpenAI."
            }
          },
          {
            "@type": "Question",
            "name": "CometAPI funziona con l'SDK Python di OpenAI?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Sì. Crea un client OpenAI, imposta api_key sulla tua chiave API di CometAPI e imposta base_url su https://api.cometapi.com/v1."
            }
          },
          {
            "@type": "Question",
            "name": "Come faccio a passare da OpenAI a CometAPI?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Modifica il base URL in https://api.cometapi.com/v1, sostituisci la chiave API con la tua chiave API di CometAPI e usa un model ID di CometAPI dalla pagina Models."
            }
          },
          {
            "@type": "Question",
            "name": "Quale model ID dovrei usare per primo?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Scegli il model ID in base al caso d'uso. Parti dalla pagina Models, quindi seleziona un modello chat, coding, image o video che corrisponda alla pagina API che intendi chiamare."
            }
          },
          {
            "@type": "Question",
            "name": "Quali linguaggi di programmazione supporta CometAPI?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "CometAPI funziona con qualsiasi linguaggio di programmazione in grado di inviare richieste HTTPS. Inizia con gli esempi curl, Python e Node.js oppure usa un SDK compatibile con OpenAI che ti consenta di sovrascrivere il base URL."
            }
          },
          {
            "@type": "Question",
            "name": "CometAPI offre una prova gratuita o una chiave API gratuita?",
            "acceptedAnswer": {
              "@type": "Answer",
              "text": "Puoi creare una chiave API di CometAPI dalla dashboard. Per verificare la disponibilità della prova gratuita, i crediti della prova gratuita e i dettagli di fatturazione, consulta la pagina dei prezzi di CometAPI e la pagina Informazioni sui prezzi."
            }
          }
        ]
      }
    ]
    }
    `}
</script>