// documentation

Setup guide

Everything you need to point a client at Kodex AI: install, configure your IDE, and call the API. If you already have a key, it takes about a minute.

Drop-in compatible

No SDK changes

Per-key budgets

5-hour rolling window

Built-in tools

Server-side web search

One base URL

Anthropic + OpenAI formats

Prerequisites

Node.js 18 or newer (for Claude Code) — nodejs.org
A Kodex API key (sk-kodex-…) — issued by your admin or reseller
A supported client — Claude Code, VS Code, Cursor, Windsurf, Cline, Roo Code or Continue

Base URLs & endpoints

Anthropic-compatible base (Claude Code, Cline, Roo)

https://softsave.tech/api/public

OpenAI-compatible base (Cursor, Windsurf, Continue, SDKs)

https://softsave.tech/api/public/v1

all endpoints

POST https://softsave.tech/api/public/v1/messages           Anthropic Messages (stream / non-stream)
POST https://softsave.tech/api/public/v1/chat/completions   OpenAI Chat Completions (stream / non-stream)
GET  https://softsave.tech/api/public/v1/models             List models (public)
GET  https://softsave.tech/check-key                         Check a key's status & usage
GET  https://softsave.tech/setup.ps1                         Windows installer
GET  https://softsave.tech/setup.sh                          macOS / Linux installer

Quick install

The installer asks for your key, checks it with the server, writes Claude Code settings (backing up any old file) and sets environment variables.

Asks for your API key
Verifies the key with the server
Writes ~/.claude/settings.json
Saves ANTHROPIC_* and OPENAI_* environment variables

Windows — PowerShell

powershell

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
irm https://softsave.tech/setup.ps1 | iex

powershell — key passed directly

$env:KODEX_API_KEY = "sk-kodex-xxx"; irm https://softsave.tech/setup.ps1 | iex

powershell — download, then run

Invoke-WebRequest https://softsave.tech/setup.ps1 -OutFile setup.ps1
.\setup.ps1

macOS and Linux

terminal

curl -fsSL https://softsave.tech/setup.sh | bash

terminal — key passed directly / CI

KODEX_API_KEY=sk-kodex-xxx bash -c "$(curl -fsSL https://softsave.tech/setup.sh)"

terminal — download, then run

curl -fsSL https://softsave.tech/setup.sh -o setup.sh
bash setup.sh

Claude Code CLI

Automatic: run the installer above. Manual: create or edit ~/.claude/settings.json:

~/.claude/settings.json

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "YOUR_API_KEY",
    "ANTHROPIC_BASE_URL": "https://softsave.tech/api/public",
    "ANTHROPIC_MODEL": "anthropic/claude-sonnet-4.5",
    "ANTHROPIC_SMALL_FAST_MODEL": "google/gemini-2.5-flash",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "anthropic/claude-sonnet-4.5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "anthropic/claude-sonnet-4.5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "google/gemini-2.5-flash",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  },
  "hasCompletedOnboarding": true
}

Or set it only for the current terminal:

bash / zsh

export ANTHROPIC_BASE_URL=https://softsave.tech/api/public
export ANTHROPIC_AUTH_TOKEN=YOUR_API_KEY
claude

PowerShell

$env:ANTHROPIC_BASE_URL = "https://softsave.tech/api/public"
$env:ANTHROPIC_AUTH_TOKEN = "YOUR_API_KEY"
claude

VS Code

The Claude Code VS Code extension reads the same ~/.claude/settings.json. Restart VS Code after saving.

Cursor

Settings → Models → add an OpenAI-compatible model:

settings

Base URL: https://softsave.tech/api/public/v1
API key:  YOUR_API_KEY
Model:    anthropic/claude-sonnet-4.5

Windsurf

Settings → AI Provider → OpenAI-compatible:

settings

Base URL: https://softsave.tech/api/public/v1
API key:  YOUR_API_KEY

Cline

VS Code settings.json

{
  "cline.apiProvider": "anthropic",
  "cline.anthropicBaseUrl": "https://softsave.tech/api/public",
  "cline.apiKey": "YOUR_API_KEY"
}

Roo Code

VS Code settings.json

{
  "roo-cline.apiProvider": "anthropic",
  "roo-cline.anthropicBaseUrl": "https://softsave.tech/api/public",
  "roo-cline.apiKey": "YOUR_API_KEY"
}

Or choose the "OpenAI Compatible" provider with base URL https://softsave.tech/api/public/v1.

Continue

~/.continue/config.yaml

models:
  - name: Kodex
    provider: openai
    model: anthropic/claude-sonnet-4.5
    apiBase: https://softsave.tech/api/public/v1
    apiKey: YOUR_API_KEY

Authentication

Every API endpoint accepts your key in either header:

headers

x-api-key: YOUR_API_KEY
# or
Authorization: Bearer YOUR_API_KEY

Messages (Anthropic format)

POST/api/public/v1/messagesauth: API key

request

{
  "model": "anthropic/claude-sonnet-4.5",
  "max_tokens": 1024,
  "messages": [{ "role": "user", "content": "Hello!" }],
  "stream": false
}

response

{
  "id": "msg_...",
  "type": "message",
  "role": "assistant",
  "model": "anthropic/claude-sonnet-4.5",
  "content": [{ "type": "text", "text": "Hello! How can I help you today?" }],
  "stop_reason": "end_turn",
  "usage": { "input_tokens": 12, "output_tokens": 15 }
}

curl

curl https://softsave.tech/api/public/v1/messages \
  -H "x-api-key: YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d '{"model":"anthropic/claude-sonnet-4.5","max_tokens":1024,"messages":[{"role":"user","content":"Hello"}]}'

PowerShell

$body = @{ model = "anthropic/claude-sonnet-4.5"; max_tokens = 1024; messages = @(@{ role = "user"; content = "Hello" }) } | ConvertTo-Json -Depth 5
Invoke-RestMethod -Method Post -Uri "https://softsave.tech/api/public/v1/messages" -Headers @{ "x-api-key" = "YOUR_API_KEY" } -ContentType "application/json" -Body $body

Python (anthropic SDK)

import anthropic
client = anthropic.Anthropic(base_url="https://softsave.tech/api/public", api_key="YOUR_API_KEY")
msg = client.messages.create(model="anthropic/claude-sonnet-4.5", max_tokens=1024, messages=[{"role":"user","content":"Hi"}])
print(msg.content[0].text)

With "stream": true you get server-sent events — message_start, content_block_delta, message_stop.

Chat completions (OpenAI format)

POST/api/public/v1/chat/completionsauth: API key

curl

curl https://softsave.tech/api/public/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"anthropic/claude-sonnet-4.5","messages":[{"role":"user","content":"Write a Python hello world"}]}'

PowerShell

$body = @{ model = "anthropic/claude-sonnet-4.5"; messages = @(@{ role = "user"; content = "Write a Python hello world" }) } | ConvertTo-Json -Depth 5
Invoke-RestMethod -Method Post -Uri "https://softsave.tech/api/public/v1/chat/completions" -Headers @{ Authorization = "Bearer YOUR_API_KEY" } -ContentType "application/json" -Body $body

Python (openai SDK)

from openai import OpenAI
client = OpenAI(base_url="https://softsave.tech/api/public/v1", api_key="YOUR_API_KEY")
r = client.chat.completions.create(model="anthropic/claude-sonnet-4.5", messages=[{"role":"user","content":"Hi"}])
print(r.choices[0].message.content)

Node.js (openai SDK)

import OpenAI from "openai";
const client = new OpenAI({ baseURL: "https://softsave.tech/api/public/v1", apiKey: "YOUR_API_KEY" });
const r = await client.chat.completions.create({ model: "anthropic/claude-sonnet-4.5", messages: [{ role: "user", content: "Hi" }] });
console.log(r.choices[0].message.content);

Models

GET/api/public/v1/modelsauth: none

curl

curl https://softsave.tech/api/public/v1/models

PowerShell

Invoke-RestMethod -Uri "https://softsave.tech/api/public/v1/models"

Every model id works on the same key and base URL, e.g. anthropic/claude-sonnet-4.5, anthropic/claude-opus-4.1, openai/gpt-5, google/gemini-2.5-pro, google/gemini-2.5-flash.

Key status

Open https://softsave.tech/check-key and paste your key to see plan, expiry, 5-hour and monthly usage.

Web search & web fetch

Built in and run on the server — nothing to install, no MCP server. Ask the model about current information or give it a link, and it searches / reads the page itself.

Plans & limits

limits per key

Plan      5-hour window   Monthly       Tokens/min   Requests/min
Pro       300,000         30,000,000    5,000        5
Max 5x    1,100,000       100,000,000   10,000       —
Max 20x   2,000,000       200,000,000   10,000       —
Demo      100,000         —             5,000        5

The 5-hour window rolls from your oldest request. Repeated (cached) context counts only 10% toward limits.

Errors

status codes

400  invalid request body
401  missing, invalid, revoked or expired API key
429  limit reached (5-hour, monthly, per-minute, request cap or quota)
502  upstream model unreachable — retry
503  upstream provider temporarily unavailable

Troubleshooting

401 / connection errors: check the key is active and not expired on the Check a key page.
PowerShell "running scripts is disabled": run the Set-ExecutionPolicy line first.
Claude Code still uses old settings: close all terminals / VS Code and open again.
429: you've hit a limit — wait for the window to reset or upgrade your plan.

Full installer scripts

setup.ps1 — https://softsave.tech/setup.ps1

# Kodex AI setup for Windows PowerShell
# Usage:  irm https://softsave.tech/setup.ps1 | iex
#    or:  $env:KODEX_API_KEY = "sk-kodex-xxx"; irm https://softsave.tech/setup.ps1 | iex
& {
  $ErrorActionPreference = "Stop"
  $Base  = "https://softsave.tech/api/public"
  $Model = "anthropic/claude-sonnet-4.5"
  $Fast  = "google/gemini-2.5-flash"
  [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12

  Write-Host "== Kodex AI setup ==" -ForegroundColor Cyan

  $Key = $env:KODEX_API_KEY
  if (-not $Key) { $Key = Read-Host "Enter your Kodex API key (sk-kodex-...)" }
  $Key = "$Key".Trim()
  if (-not ($Key.StartsWith("sk-") -or $Key.StartsWith("kx-"))) {
    Write-Host "Error: invalid key (must start with sk-kodex-)" -ForegroundColor Red; return
  }

  Write-Host "Checking key..."
  $status = 0
  try {
    Invoke-WebRequest -UseBasicParsing -Method Post -Uri "$Base/v1/messages" -Headers @{ "x-api-key" = $Key } -ContentType "application/json" -Body "{}" | Out-Null
    $status = 200
  } catch {
    if ($_.Exception.Response) { $status = [int]$_.Exception.Response.StatusCode } else { $status = 0 }
  }
  if ($status -eq 401) { Write-Host "Error: key rejected (invalid, revoked or expired)." -ForegroundColor Red; return }
  if ($status -eq 0)   { Write-Host "Error: cannot reach $Base" -ForegroundColor Red; return }
  Write-Host "Key OK." -ForegroundColor Green

  $Dir  = Join-Path $HOME ".claude"
  $File = Join-Path $Dir "settings.json"
  New-Item -ItemType Directory -Force -Path $Dir | Out-Null
  if (Test-Path $File) {
    Copy-Item $File "$File.bak.$([DateTimeOffset]::Now.ToUnixTimeSeconds())"
    Write-Host "Backed up existing settings.json"
  }
  $Settings = [ordered]@{
    env = [ordered]@{
      ANTHROPIC_AUTH_TOKEN = $Key
      ANTHROPIC_BASE_URL = $Base
      ANTHROPIC_MODEL = $Model
      ANTHROPIC_SMALL_FAST_MODEL = $Fast
      ANTHROPIC_DEFAULT_SONNET_MODEL = $Model
      ANTHROPIC_DEFAULT_OPUS_MODEL = $Model
      ANTHROPIC_DEFAULT_HAIKU_MODEL = $Fast
      CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1"
    }
    hasCompletedOnboarding = $true
  } | ConvertTo-Json -Depth 5
  # UTF-8 without BOM (a BOM breaks Claude Code's JSON parser)
  [IO.File]::WriteAllText($File, $Settings, (New-Object System.Text.UTF8Encoding($false)))
  Write-Host "Wrote $File"

  $vars = @{
    KODEX_API_KEY = $Key
    ANTHROPIC_BASE_URL = $Base
    ANTHROPIC_AUTH_TOKEN = $Key
    OPENAI_BASE_URL = "$Base/v1"
    OPENAI_API_KEY = $Key
  }
  foreach ($k in $vars.Keys) {
    [Environment]::SetEnvironmentVariable($k, $vars[$k], "User")
    Set-Item -Path "Env:$k" -Value $vars[$k]
  }
  Write-Host "Saved environment variables for your user."

  Write-Host ""
  Write-Host "Done. Run: claude   (VS Code users: restart VS Code)" -ForegroundColor Green
}

setup.sh — https://softsave.tech/setup.sh

#!/usr/bin/env bash
# Kodex AI setup for macOS / Linux
# Usage:  curl -fsSL https://softsave.tech/setup.sh | bash
#    or:  KODEX_API_KEY=sk-kodex-xxx bash -c "$(curl -fsSL https://softsave.tech/setup.sh)"
set -eu

BASE="https://softsave.tech/api/public"
MODEL="anthropic/claude-sonnet-4.5"
FAST="google/gemini-2.5-flash"

echo "== Kodex AI setup =="

command -v curl >/dev/null 2>&1 || { echo "Error: curl is required."; exit 1; }

KEY="${KODEX_API_KEY:-}"
if [ -z "$KEY" ]; then
  if [ -r /dev/tty ]; then
    printf "Enter your Kodex API key (sk-kodex-...): "
    read -r KEY < /dev/tty
  else
    echo "Error: no terminal. Run with KODEX_API_KEY=sk-kodex-xxx"; exit 1
  fi
fi
KEY="$(printf '%s' "$KEY" | tr -d '[:space:]')"
case "$KEY" in
  sk-*|kx-*) ;;
  *) echo "Error: invalid key (must start with sk-kodex-)"; exit 1 ;;
esac

echo "Checking key..."
code=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE/v1/messages" \
  -H "x-api-key: $KEY" -H "content-type: application/json" -d '{}' || echo "000")
if [ "$code" = "401" ]; then echo "Error: key rejected (invalid, revoked or expired)."; exit 1; fi
if [ "$code" = "000" ]; then echo "Error: cannot reach $BASE"; exit 1; fi
echo "Key OK."

DIR="$HOME/.claude"
FILE="$DIR/settings.json"
mkdir -p "$DIR"
if [ -f "$FILE" ]; then
  cp "$FILE" "$FILE.bak.$(date +%s)"
  echo "Backed up existing settings.json"
fi
cat > "$FILE" <<EOF
{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "$KEY",
    "ANTHROPIC_BASE_URL": "$BASE",
    "ANTHROPIC_MODEL": "$MODEL",
    "ANTHROPIC_SMALL_FAST_MODEL": "$FAST",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "$MODEL",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "$MODEL",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "$FAST",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  },
  "hasCompletedOnboarding": true
}
EOF
chmod 600 "$FILE"
echo "Wrote $FILE"

for f in "$HOME/.bashrc" "$HOME/.zshrc" "$HOME/.profile"; do
  [ -f "$f" ] || continue
  # remove old Kodex block, then append fresh one
  tmp="$(mktemp)"
  sed '/# >>> Kodex AI >>>/,/# <<< Kodex AI <<</d' "$f" > "$tmp" && cat "$tmp" > "$f" && rm -f "$tmp"
  cat >> "$f" <<EOF
# >>> Kodex AI >>>
export KODEX_API_KEY="$KEY"
export ANTHROPIC_BASE_URL="$BASE"
export ANTHROPIC_AUTH_TOKEN="$KEY"
export OPENAI_BASE_URL="$BASE/v1"
export OPENAI_API_KEY="$KEY"
# <<< Kodex AI <<<
EOF
  echo "Updated $f"
done

echo ""
echo "Done. Open a new terminal, then run: claude"
echo "VS Code users: restart VS Code."