Zenic API

Setup

1. Create an API key in Settings → Developer API.
2. Edit ~/.claude/settings.json (or settings.local.json for machine-only overrides).
3. Paste the env block below and replace the token.
4. Restart Claude Code or open a new terminal session.
5. Run claude in your project directory.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.zenic.my",
    "ANTHROPIC_AUTH_TOKEN": "sk-zenic-...",
    "ANTHROPIC_MODEL": "azno-1.5-mini"
  }
}

Env vars

• ANTHROPIC_BASE_URL — API host without /v1. Claude Code appends /v1/messages itself.
• ANTHROPIC_AUTH_TOKEN — your sk-zenic-… key.
• ANTHROPIC_MODEL — set to azno-1.5-mini. Claude Sonnet/Opus IDs also work as aliases; all map to Azno 1.5 Mini.

Verify

# Should return authentication_error (401), not 404
curl -s -X POST https://api.zenic.my/v1/messages \
  -H "x-api-key: sk-zenic-test" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{"model":"azno-1.5-mini","max_tokens":16,"messages":[{"role":"user","content":"ping"}]}'

A 404 means the base URL is wrong. A 401 with authentication_error means the route is reachable — swap in your real key.

Option A — Anthropic provider (recommended)

Uses POST /v1/messages with native tool streaming. OpenCode's Anthropic SDK expects baseURL to include /v1 — the opposite of Claude Code.

1. Create ~/.config/opencode/opencode.json.
2. Set ZENIC_API_KEY in your shell profile or pass it inline.
3. Paste the config below and pick the model on startup.

{
  "$schema": "https://opencode.ai/config.json",
  "model": "anthropic/azno-1.5-mini",
  "provider": {
    "anthropic": {
      "options": {
        "baseURL": "https://api.zenic.my/v1",
        "apiKey": "{env:ZENIC_API_KEY}"
      },
      "models": {
        "azno-1.5-mini": {
          "name": "Azno 1.5 Mini"
        }
      }
    }
  }
}

# ~/.bashrc or ~/.zshrc
export ZENIC_API_KEY="sk-zenic-..."

Option B — OpenAI-compatible provider

Uses POST /v1/chat/completions. Good when you want the OpenAI SDK path inside OpenCode or only need text completions.

{
  "$schema": "https://opencode.ai/config.json",
  "model": "zenic/azno-1.5-mini",
  "provider": {
    "zenic": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Zenic",
      "options": {
        "baseURL": "https://api.zenic.my/v1",
        "apiKey": "{env:ZENIC_API_KEY}"
      },
      "models": {
        "azno-1.5-mini": {
          "name": "Azno 1.5 Mini",
          "limit": {
            "context": 256000,
            "output": 8192
          }
        }
      }
    }
  }
}

Select model in OpenCode

After editing the config, run opencode and choose anthropic/azno-1.5-mini or zenic/azno-1.5-mini depending on which option you configured. Streaming is on by default in the TUI.

OpenAI — POST /chat/completions

Set "stream": true. Response is text/event-stream with data: {…} lines.

curl -N https://api.zenic.my/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "azno-1.5-mini",
    "stream": true,
    "messages": [
      { "role": "user", "content": "Write a haiku about debugging." }
    ]
  }'

Typical chunk sequence:

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"Hello"},"finish_reason":null}]}

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":" world"},"finish_reason":null}]}

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":12,"completion_tokens":2,"total_tokens":14}}

data: [DONE]

Read choices[0].delta.content from each chunk. Stop when you see data: [DONE].

Anthropic — POST /messages

Set "stream": true and header anthropic-version: 2023-06-01. Events use event: + data: pairs.

curl -N https://api.zenic.my/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "azno-1.5-mini",
    "max_tokens": 1024,
    "stream": true,
    "messages": [
      { "role": "user", "content": "Write a haiku about debugging." }
    ]
  }'

Event lifecycle:

Example text delta:

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":5}}

event: message_stop
data: {"type":"message_stop"}

For tool-using agents (Claude Code, OpenCode), watch for stop_reason: "tool_use" and content_block entries with type: "tool_use".

List models

GET https://api.zenic.my/v1/models

{
  "object": "list",
  "data": [{ "id": "azno-1.5-mini", "object": "model", "owned_by": "zenic" }]
}

Chat completions

POST /chat/completions — standard OpenAI shape. Context capped at 256k tokens (oldest turns dropped). Roles: user, assistant.

POST https://api.zenic.my/v1/chat/completions
Authorization: Bearer sk-zenic-...
Content-Type: application/json

{
  "model": "azno-1.5-mini",
  "stream": false,
  "messages": [
    { "role": "user", "content": "Your prompt" }
  ]
}

cURL (non-streaming)

curl https://api.zenic.my/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "azno-1.5-mini",
    "messages": [
      { "role": "user", "content": "Explain recursion in one paragraph." }
    ]
  }'

Python — OpenAI SDK

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.zenic.my/v1",
)

# Non-streaming
response = client.chat.completions.create(
    model="azno-1.5-mini",
    messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)

# Streaming
stream = client.chat.completions.create(
    model="azno-1.5-mini",
    stream=True,
    messages=[{"role": "user", "content": "Hello"}],
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Python — Anthropic SDK

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.zenic.my",
)

# Non-streaming
message = client.messages.create(
    model="azno-1.5-mini",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
print(message.content[0].text)

# Streaming
with client.messages.stream(
    model="azno-1.5-mini",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

HTTP status codes

• 401 — missing or invalid API key
• 400 model_not_found — OpenAI route: only azno-1.5-mini accepted
• 402 insufficient_balance — weekly free quota used and no paid balance
• 404 — wrong base URL (see Quick start table)

Anthropic error shape

{
  "type": "error",
  "error": {
    "type": "authentication_error",
    "message": "Invalid API key provided."
  }
}

Limits

• One public model: azno-1.5-mini
• 256k context window — oldest messages trimmed first
• Usage billed against your plan quota, then paid balance