> ## Content Index
> Fetch the complete content index at: https://adrianoamalfi.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# OpenCode Go: abbonarsi, configurare e usare i modelli open per coding agent
- URL: https://adrianoamalfi.com/tech-scratchpad/opencode-go-guida-abbonamento/
- Published: 2026-07-30T08:51:54.000Z
- Updated: 2026-07-30T08:57:10.000Z
- Description: Guida all'abbonamento OpenCode Go: da $5 il primo mese per 16 modelli open ottimizzati per coding agent, con limiti generosi e API OpenAI-compatibile.
- Author: Adriano Amalfi
- Tags: Scratchpad, AI Tools, Tutorial, AI Agentica, OpenCode, #Tech Scratchpad: Appunti avanzati e esperimenti per esperti e amatoriali

*Testato il:* 2026-07-29 *Ambiente:* macOS 15.5 · Node 24.15.0 · OpenCode 1.18.9

## Prerequisiti

- Un terminale moderno: [WezTerm](https://wezterm.org/?ref=adrianoamalfi.com), [Alacritty](https://alacritty.org/?ref=adrianoamalfi.com), [Ghostty](https://ghostty.org/?ref=adrianoamalfi.com) o [Kitty](https://sw.kovidgoyal.net/kitty/?ref=adrianoamalfi.com) (l'esperienza con terminali che non supportano il **protocollo Kitty** è degradata)
- Node.js 18+ se installi via npm, oppure Homebrew su macOS/Linux
- Una carta di credito per la sottoscrizione (il primo mese costa $5, poi $10/mese)

## 1\. Installare OpenCode

Parti dallo script di installazione ufficiale:

```bash
curl -fsSL https://opencode.ai/install | bash
```

Alternative:

```bash
# Via npm
npm install -g opencode-ai

# Via Homebrew (tap ufficiale, più aggiornato della formula core)
brew install anomalyco/tap/opencode

# Arch Linux
sudo pacman -S opencode
```

Controlla che l'installazione funzioni:

```bash
opencode --version
```

Vedrai un numero di versione (es. `1.18.9`).

Se il comando non viene trovato, chiudi e riapri il terminale o controlla che il path di installazione sia nel tuo `PATH`.

## 2\. Sottoscrivere OpenCode Go

L'abbonamento Go parte da *$5 il primo mese*, poi *$10/mese*. I limiti sono misurati in *valore-dollaro*, non in richieste: più il modello è economico, più richieste puoi fare.

Vai su [OpenCode Go](https://opencode.ai/go?ref=SZ5ZSQC609), clicca su *Subscribe to Go* e completa la registrazione. Ti servirà un account se non ne hai già uno.

SPONSORED 

Usa il mio link di referral, se ti iscrivi e ti abboni a Go, entrambi riceveremo un credito di utilizzo di $5 da applicare ai limiti di utilizzo Go

  
[Usa l'offerta Opencode ](https://opencode.ai/go?ref=SZ5ZSQC609) 

Dopo il pagamento, la dashboard mostra un'API key.

L'API key non viene più mostrata — ****Copiala subito**: dopo che lasci la pagina di conferma, la chiave non è più visibile. Se la perdi, puoi rigenerarla dal \[pannello di controllo\](https://opencode.ai/auth) nella sezione API Keys, ma non potrai recuperare quella originale.

I limiti inclusi nell'abbonamento:

![](https://adrianoamalfi.com/content/images/2026/07/image.png)

| Finestra    | Valore in $ | Cosa significa in pratica                                    |
| ----------- | ----------- | ------------------------------------------------------------ |
| 5 ore       | $12         | \~31.650 richieste con DeepSeek V4 Flash, \~120 con Grok 4.5 |
| Settimanale | $30         | \~79.050 richieste con DeepSeek V4 Flash                     |
| Mensile     | $60         | \~158.150 richieste con DeepSeek V4 Flash                    |

Se superi i limiti, abilita l'opzione *Use balance* nel pannello di controllo: OpenCode attingerà automaticamente al tuo credito Zen, se ne hai.

Puoi anche continuare a usare i modelli gratuiti di OpenCode senza consumare il credito Go.

## 3\. Connettere Go a OpenCode

Apri OpenCode in un terminale dentro una qualsiasi directory di progetto:

```bash
opencode
```

Una volta nella TUI, esegui il comando `/connect`:

```text
/connect
```

Si apre un menu di provider. Seleziona *OpenCode Go* e incolla l'API key che hai copiato nello step precedente.

```text
┌ API key
│
└ enter
```

Se la chiave è valida, OpenCode conferma la connessione senza dire altro. Per controllare, esegui:

```text
/models
```

Vedrai la lista dei 16 modelli Go disponibili, ciascuno con il prefisso `opencode-go/`. Al momento in cui scrivo, questi sono:

- `opencode-go/grok-4.5`
- `opencode-go/glm-5.2`
- `opencode-go/glm-5.1`
- `opencode-go/kimi-k3`
- `opencode-go/kimi-k2.7-code`
- `opencode-go/kimi-k2.6`
- `opencode-go/mimo-v2.5`
- `opencode-go/mimo-v2.5-pro`
- `opencode-go/minimax-m3`
- `opencode-go/minimax-m2.7`
- `opencode-go/qwen3.7-max`
- `opencode-go/qwen3.7-plus`
- `opencode-go/qwen3.6-plus`
- `opencode-go/deepseek-v4-pro`
- `opencode-go/deepseek-v4-flash`
- `opencode-go/hy3`

Un solo abbonato per workspace — Solo un membro per workspace può sottoscrivere Go. Se lavori in team, coordinatevi su chi attiva l'abbonamento: condividete la stessa API key oppure usate account e workspace separati.

## 4\. Selezionare e usare un modello Go

Per cambiare modello al volo, usa il comando `/model`:

```text
/model opencode-go/deepseek-v4-pro
```

OpenCode passa immediatamente al modello scelto. L'indicatore in basso a destra nella TUI mostra il nome del provider e del modello attivo.

Prova a fargli una domanda per vedere se risponde:

```text
Scrivi una funzione in TypeScript che inverta una stringa
```

Se risponde con codice funzionante, tutto ok.

### Quale modello scegliere?

Dipende da cosa stai facendo e da quanto vuoi spendere rispetto ai limiti. Una selezione pratica:

- ***DeepSeek V4 Flash*** è il più economico ($0.14/$0.28 per 1M token input/output): ti dura settimane di uso intenso. Ottimo per refactoring, generazione di boilerplate e task ripetitivi.
- ***DeepSeek V4 Pro*** ($0.435/$0.87) è il miglior compromesso qualità/prezzo per il coding day-to-day.
- ***Kimi K3*** ($3.00/$15.00) è eccellente ma costoso: consuma il limite 5 ore in circa 110 richieste. Tienilo per problemi complessi che richiedono ragionamento multi-step.
- **Qwen3.7 Max** ($2.50/$7.50) e *Grok 4.5* ($2.00/$6.00) sono nella fascia alta: usali quando DeepSeek non basta.
- ***MiMo-V2.5*** ($0.14/$0.28) è economico quanto DeepSeek V4 Flash, ma con una personalità diversa: vale la pena provarlo se Flash ti dà risposte che non ti convincono.

## 5\. (Opzionale) Usare l'API Go con AI SDK o altri tool

L'abbonamento Go funziona anche fuori da OpenCode, con qualsiasi agent o tool che parli API **OpenAI-compatibile**.

### Endpoint

La maggior parte dei modelli usa l'endpoint *Chat Completions*:

```text
https://opencode.ai/zen/go/v1/chat/completions
```

Alcuni modelli (MiniMax, Qwen3.7) usano invece un endpoint *Messages*\-style:

```text
https://opencode.ai/zen/go/v1/messages
```

Endpoint diversi per modelli diversi — Non tutti i modelli usano lo stesso endpoint. MiniMax e Qwen3.7 richiedono l'endpoint \`/messages\` e il package \`@ai-sdk/anthropic\` invece di \`@ai-sdk/openai-compatible\`. Controlla sempre la [tabella endpoint](https://opencode.ai/docs/go/?ref=adrianoamalfi.com#endpoints) prima di configurare un modello in un tool esterno.

La tabella completa con model ID, endpoint e package AI SDK è nella [documentazione ufficiale](https://opencode.ai/docs/go/?ref=adrianoamalfi.com#endpoints).

### Esempio con curl

```bash
curl -s https://opencode.ai/zen/go/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer LA_TUA_API_KEY_GO" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Dimmi ciao in Python"}]
  }' | jq '.choices[0].message.content'
```

Se tutto funziona, vedrai qualcosa come `"print('ciao')"`.

### Esempio con Vercel AI SDK

```bash
npm install @ai-sdk/openai-compatible ai
```

```typescript
import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";

const go = createOpenAICompatible({
  name: "opencode-go",
  baseURL: "https://opencode.ai/zen/go/v1",
  apiKey: process.env.OPENCODE_GO_API_KEY,
});

const { text } = await generateText({
  model: go.chatModel("deepseek-v4-pro"),
  prompt: "Scrivi una funzione TypeScript che formatta una data in italiano.",
});

console.log(text);
```

Per i modelli che usano l'endpoint Messages (MiniMax e Qwen3.7), devi usare `@ai-sdk/anthropic` invece di `@ai-sdk/openai-compatible`. Controlla la [tabella endpoint](https://opencode.ai/docs/go/?ref=adrianoamalfi.com#endpoints) per sapere quale package usare con ciascun modello.

## Verifica

Per controllare che tutto funzioni:

1. Dentro OpenCode TUI, esegui `/models`: devi vedere tutti e 16 i modelli con il prefisso `opencode-go/`
2. Selezionane uno con `/model opencode-go/deepseek-v4-flash` e fagli una domanda semplice: deve rispondere
3. Controlla i consumi dal [pannello di controllo](https://opencode.ai/auth?ref=adrianoamalfi.com) per vedere se le richieste sono contabilizzate

## Limiti noti

- *Un solo abbonato per workspace*: se più persone nel team vogliono usare Go, devono usare la stessa API key o abbonarsi con account separati e workspace separati
- *I modelli cambiano nel tempo*: OpenCode testa e aggiunge nuovi modelli periodicamente. Quelli elencati qui sono i 16 disponibili a luglio 2026\. Usa `/models` per vedere la lista aggiornata
- *Niente modelli proprietari*: Go include solo modelli open-weight. Se ti servono Claude, GPT o Gemini, devi usare Zen, un provider diretto o un abbonamento ChatGPT Plus/GitHub Copilot
- *I limiti in dollari*, non in richieste, rendono difficile stimare quante interazioni farai. Inizia con DeepSeek V4 Flash e passa a modelli più costosi solo quando ti servono davvero