StringRoute - 5-Minute Getting Started Guide

Welcome to StringRoute. This guide helps you complete your first conversation, understand model selection, check balance and usage, and answer the most common beginner questions. No code, no tool configuration, just the web app.

Step 1: Log in to your account

1. Open the StringRoute web entry in your browser.
2. Log in with your registered email address. If you have not registered yet, contact your administrator for an invitation link or access.
3. After login, your account information, avatar, or email should appear in the top-right corner or sidebar. If you can see it, login succeeded.

If login fails, check the following:

• Whether the email address matches the one used during registration, including spaces and casing
• Whether the verification code or invitation email is in spam
• Whether your browser blocks pop-ups, because some third-party login flows open a new window
• Whether your company network or proxy restricts the login page
• Whether an incognito browser window works

Step 2: Ask your first question

After login, you will enter the Webchat page. Type the following message into the input box and press Enter:

Who are you? In three sentences, explain what you can help me do.

You should see the AI start streaming a response.

If the page replies normally, congratulations. You are ready to use StringRoute.

It works like a normal chat app: type, send, and read the reply. Try these examples to get a feel for what AI can do:

Small tip: Start a new conversation for each new task. If you mix email writing, translation, and summarization in one long conversation, the AI may blend earlier context into later answers.

Step 3: Choose a model

A model is the AI "brain". Different models have different capabilities and prices. You will see a model selector near the input box.

Not sure which one to choose? Start with the default model and switch only when needed.

A simple rule:

• Want higher quality -> choose a stronger model
• Want faster and cheaper output -> choose a lightweight model
• Not sure -> use the default model

After using StringRoute for a while, you will naturally learn which models fit your own workflow.

Step 4: Check balance and usage

Before heavy usage, spend one minute understanding three things:

1. Your current balance or remaining quota - this determines how long you can continue using the service. It is usually near your avatar or under Settings / Account.
2. How much each conversation costs - the usage history page shows detailed consumption for each request. Short Q&A costs less; long documents and multi-turn reasoning cost more.
3. Whether pricing differs by model - stronger models are usually more expensive, while lightweight models are cheaper.

Main factors that affect usage:

Cost-saving tips:

• Start a new conversation for a new task
• Ask for an outline first, then go deeper section by section
• Use lightweight models for simple tasks
• Check usage records every few days so you know the trend

Step 5: Three common beginner questions

Q1: There are too many models. Which one should I choose?

Use the default model first. It works for most daily tasks. Switch only when response quality is not enough, the material is too long, or cost becomes too high. Do not try every model at the beginning.

Q2: How are balance and usage calculated? Why is every request different?

Usage depends on the model, input length, output length, file uploads, and conversation history. In short: the more you give the AI, the more you ask it to generate, and the stronger the model, the more it costs. You do not need to watch every single number. Focus on total balance and usage trend.

Q3: Do I need to install anything on my computer?

No. If you can open a browser, you can use Webchat. Tools such as VS Code, Codex, and Cursor are for developers. If you only want to ask questions, write, translate, or summarize on the web, you do not need to install anything.

Prerequisite: Install the Node.js Runtime

Use this page only for tools installed through npm, such as OpenClaw. The official Claude Code installer does not need Node.js. This site has no Gemini CLI guide. For Codex, follow the check in the Codex install script.

Windows

Option one, recommended: go to the Node.js website and install the LTS version.

Options two and three, using package managers:

choco install nodejs-lts
# or
scoop install nodejs-lts

macOS

brew install node
# or download the macOS installer from the official website

Linux

# Ubuntu / Debian
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

# CentOS / RHEL
curl -fsSL https://rpm.nodesource.com/setup_lts.x | sudo bash -
sudo yum install -y nodejs

Verify Installation

node --version
npm --version

If both commands print version numbers, Node.js and npm are ready.

Before you start: have you installed Node.js? Run node --version and npm --version. If they do not print version numbers, finish Install the Node.js Runtime first.

Codex (CLI and VS Code Extension)

Codex CLI and the VS Code Codex extension share the same configuration file: ~/.codex/config.toml.

Available models: gpt-6-astra, gpt-5.6-sol, gpt-5.6-luna.

Option 1: One-Line Script (Recommended)

The script checks Node.js and Codex CLI, asks for your API Key, and writes the configuration to ~/.codex. If STRING_AI_API_KEY is already set, it uses that value first and does not read an existing OPENAI_API_KEY.

# Windows PowerShell
irm https://www.string.llc/install/codex.ps1 | iex

After writing the configuration, Codex CLI and the app client will both use it. Restart any open CLI, VS Code, or Codex client so the new configuration is loaded.

Option 2: Manual Configuration

If the one-line script is unavailable, create config.toml and auth.json manually.

Minimal configuration:

model_provider = "OpenAI"
model = "gpt-6-astra"

[model_providers.OpenAI]
base_url = "https://www.string.llc/v1"

Full manual setup for Windows PowerShell, including backups and auth.json:

$codexDir = "$env:USERPROFILE\.codex"
if (-not (Test-Path $codexDir)) { mkdir $codexDir | Out-Null }
if (Test-Path "$codexDir\config.toml") {
  Copy-Item "$codexDir\config.toml" "$codexDir\config.toml.bak.$(Get-Date -Format yyyyMMddHHmmss)"
}
if (Test-Path "$codexDir\auth.json") {
  Copy-Item "$codexDir\auth.json" "$codexDir\auth.json.bak.$(Get-Date -Format yyyyMMddHHmmss)"
}
@"
model_provider = "OpenAI"
model = "gpt-6-astra"
review_model = "gpt-6-astra"
model_reasoning_effort = "xhigh"
disable_response_storage = true
network_access = "enabled"
windows_wsl_setup_acknowledged = true

[model_providers.OpenAI]
name = "OpenAI"
base_url = "https://www.string.llc/v1"
wire_api = "responses"
requires_openai_auth = true

[features]
goals = true
"@ | Out-File -FilePath "$codexDir\config.toml" -Encoding utf8

@"
{
  "OPENAI_API_KEY": "YOUR_API_KEY"
}
"@ | Out-File -FilePath "$codexDir\auth.json" -Encoding utf8

After configuration, restart Codex CLI or the Codex app client.

Migrate an Old OAuth Session (Optional)

If you previously logged in to Codex with OAuth, old sessions may temporarily disappear after config.toml is set to model_provider = "OpenAI". They are not deleted. The public install has no migration command. Contact support if you need the old sessions back, and do not edit the session database yourself.

Verify Configuration

Start a simple task in Codex or VS Code:

Read the current project structure and summarize what this project may do. Do not modify files.

If Codex replies normally and the StringRoute console shows the corresponding usage record, the configuration is working.

Image MCP (optional)

Set STRING_AI_API_KEY to an ordinary sk- key (WebChat and Launcher-managed keys are rejected), then add this to ~/.codex/config.toml:

[mcp_servers.stringai_image]
url = "https://mcp.string.llc/mcp"
bearer_token_env_var = "STRING_AI_API_KEY"

Do not put a real key in config.toml. Restart Codex after saving. Tools: generate_image, get_image_task, list_image_models. Billing reuses the existing plan quota and usage path.

Before you start, make sure you have a usable StringRoute sk- key. Replace YOUR_API_KEY with your own key in the examples below, and never commit a real key to a repository or public document.

OpenCode Installation

OpenCode is an open-source coding agent with a terminal CLI and a Desktop app. Install it from the official download page: https://opencode.ai/download.

The current page is OpenCode v2. Older docs may still show https://opencode.ai/install and the npm package opencode-ai; use the v2 commands below.

CLI

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

brew install anomalyco/tap/opencode-v2

npm install -g @opencode/cli

bun install -g --trust @opencode/cli

After installing, open a new terminal and run opencode.

Desktop

Download from https://opencode.ai/download:

• macOS (Apple Silicon / Intel): .dmg
• Windows (x64): NSIS installer
• Linux: .deb / .rpm

On macOS you can also run:

brew install --cask opencode-desktop

OpenCode Connection

CLI and Desktop share the same StringRoute endpoint. Available models: gpt-6-astra, gpt-5.6-sol, gpt-5.6-luna.

You can add the provider in Desktop Settings, or write opencode.json. Either way works.

Desktop Settings

1. Open OpenCode Desktop and go to Settings.
2. Open Providers and click Add Provider.
3. Choose OpenAI or OpenAI-compatible / Custom.
4. Fill in:

1. Save, then pick gpt-6-astra (or another StringRoute model) in the model list.

If the form only asks for an API Key, add the Base URL in opencode.json as shown below, then come back and connect the key in Settings.

CLI can use /connect after the Base URL is set.

Config file

CLI and Desktop both read ~/.config/opencode/opencode.json (or opencode.jsonc).

Create the file if it does not exist:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openai": {
      "options": {
        "baseURL": "https://www.string.llc/v1",
        "apiKey": "YOUR_API_KEY"
      },
      "models": {
        "gpt-6-astra": { "name": "GPT-6 Astra" },
        "gpt-5.6-sol": { "name": "GPT-5.6 Sol" },
        "gpt-5.6-luna": { "name": "GPT-5.6 Luna" }
      }
    }
  },
  "model": "openai/gpt-6-astra"
}

You can omit apiKey here and enter it later in Desktop Settings or with /connect.

Restart any open CLI or Desktop window after saving. If StringRoute console shows the matching usage, the connection is working.

Before you start, make sure you have a usable StringRoute sk- key. Replace YOUR_STRING_AI_API_KEY with your own key in the examples below, and never commit a real key to a repository or public document.

ClaudeCode Installation

Claude Code can be installed with the official native installer, Homebrew, WinGet, or npm. After installation, run claude --version or claude doctor to verify the CLI.

Windows CLI

Use the official native installer. PowerShell and CMD use different commands.

irm https://claude.ai/install.ps1 | iex

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

winget install Anthropic.ClaudeCode
winget upgrade Anthropic.ClaudeCode

Then open a new terminal and run:

claude --version
claude doctor

Git for Windows is recommended for native Windows use. Without it, Claude Code falls back to PowerShell for shell tools.

MacOS CLI

On macOS, install with the native installer, Homebrew cask, or npm.

curl -fsSL https://claude.ai/install.sh | bash

brew install --cask claude-code
brew upgrade claude-code

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

npm install -g @anthropic-ai/claude-code
npm install -g @anthropic-ai/claude-code@latest

Verify the install:

claude --version
claude doctor

ClaudeCode Connection

When using StringRoute as the Claude Code gateway, configure ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN. Use the site root for ANTHROPIC_BASE_URL; do not append /v1.

CC Switch Connection

If you manage Claude Code through CC Switch, create or switch to a Claude Code profile and set these environment variables:

Note: YOUR_STRING_AI_API_KEY means the API Key you create yourself in the StringRoute console. When creating the API Key, make sure to select the claude api group, otherwise Claude Code cannot connect through the Claude API channel.

Save the profile, then start Claude Code from CC Switch or restart your terminal and run:

claude

Inside Claude Code, run /status and confirm Anthropic base URL points to https://www.string.llc and the credential source is ANTHROPIC_AUTH_TOKEN.

For a quick temporary test, set the variables in the current terminal session:

export ANTHROPIC_BASE_URL="https://www.string.llc"
export ANTHROPIC_AUTH_TOKEN="YOUR_STRING_AI_API_KEY"
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
export CLAUDE_CODE_ATTRIBUTION_HEADER=0
claude

set ANTHROPIC_BASE_URL=https://www.string.llc
set ANTHROPIC_AUTH_TOKEN=YOUR_STRING_AI_API_KEY
set CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1
set CLAUDE_CODE_ATTRIBUTION_HEADER=0
claude

$env:ANTHROPIC_BASE_URL = "https://www.string.llc"
$env:ANTHROPIC_AUTH_TOKEN = "YOUR_STRING_AI_API_KEY"
$env:CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1"
$env:CLAUDE_CODE_ATTRIBUTION_HEADER = "0"
claude

Configuration File Method

For a persistent setup, write the variables to the user-level Claude Code settings file:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://www.string.llc",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_STRING_AI_API_KEY",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "CLAUDE_CODE_ATTRIBUTION_HEADER": "0"
  }
}

mkdir -p ~/.claude
cat > ~/.claude/settings.json <<'JSON'
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://www.string.llc",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_STRING_AI_API_KEY",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "CLAUDE_CODE_ATTRIBUTION_HEADER": "0"
  }
}
JSON

$claudeDir = Join-Path $env:USERPROFILE ".claude"
New-Item -ItemType Directory -Force -Path $claudeDir | Out-Null
@'
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://www.string.llc",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_STRING_AI_API_KEY",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "CLAUDE_CODE_ATTRIBUTION_HEADER": "0"
  }
}
'@ | Set-Content -Path (Join-Path $claudeDir "settings.json") -Encoding UTF8

Do not put real credentials in project-level .claude/settings.json, because that file is usually committed and shared with the team. If the configuration should apply only to one local project, use .claude/settings.local.json and make sure it is ignored by git.

Restart your terminal and run:

claude

Inside Claude Code, run /status to confirm the base URL and credential source. If Claude Code still uses an old login, run /logout and start it again.

Image MCP (optional)

StringRoute exposes a remote image MCP so Claude Code can generate images directly. This is independent of the Claude API gateway setup above. Use an ordinary sk- key from the console; WebChat and Launcher-managed keys are rejected.

claude mcp add --transport http stringai-image https://mcp.string.llc/mcp --header "Authorization: Bearer YOUR_STRING_AI_API_KEY"

Restart Claude Code, then run /mcp and confirm stringai-image is connected. Tools: generate_image, get_image_task, list_image_models. Billing reuses the existing plan quota and usage path.

Before you start: have you installed Node.js? Run node --version and npm --version. If they do not print version numbers, finish Install the Node.js Runtime first.

OpenClaw

Requires Node.js 22.19+ or Node.js 24, recommended.

Installation

npm install -g openclaw@latest
npx openclaw --version

Option 1: Configuration Patch (Recommended)

Create openclaw-stringai.json:

{
  "agents": {
    "defaults": {
      "model": { "primary": "stringai/gpt-6-astra" },
      "models": {
        "stringai/gpt-6-astra": { "alias": "StringRoute GPT-6 Astra" },
        "stringai/gpt-5.6-sol": { "alias": "StringRoute GPT-5.6 Sol" },
        "stringai/gpt-5.6-luna": { "alias": "StringRoute GPT-5.6 Luna" }
      }
    }
  },
  "models": {
    "providers": {
      "stringai": {
        "baseUrl": "https://www.string.llc/v1",
        "apiKey": "${STRING_AI_API_KEY}",
        "api": "openai-completions",
        "timeoutSeconds": 120,
        "models": [
          { "id": "gpt-6-astra", "name": "GPT-6 Astra", "contextWindow": 128000, "maxTokens": 16384 },
          { "id": "gpt-5.6-sol", "name": "GPT-5.6 Sol", "contextWindow": 128000, "maxTokens": 16384 },
          { "id": "gpt-5.6-luna", "name": "GPT-5.6 Luna", "contextWindow": 128000, "maxTokens": 16384 }
        ]
      }
    }
  }
}

Set the environment variable and apply the configuration:

# Windows PowerShell
$env:STRING_AI_API_KEY = "YOUR_API_KEY"
npx openclaw config patch --file openclaw-stringai.json --replace-path "models.providers.stringai.models"

# macOS / Linux / WSL
export STRING_AI_API_KEY="YOUR_API_KEY"
npx openclaw config patch --file openclaw-stringai.json --replace-path "models.providers.stringai.models"

If old model configuration already exists, use --replace-path. A "Refusing to replace" error means this parameter is required. On success the command asks you to restart the gateway. The update count depends on the existing config. Do not match a fixed number.

Verify and Use

npx openclaw config validate      # Config valid: ~/.openclaw/openclaw.json
npx openclaw models status        # Shows StringRoute models and a partially hidden API Key

# Local mode
npx openclaw agent --local --session-id my-session --message "Hello" --model stringai/gpt-6-astra
# Or start the gateway first
npx openclaw onboard --install-daemon
npx openclaw agent --message "Hello" --model stringai/gpt-6-astra

Persist the Environment Variable

# Windows PowerShell, as administrator
[Environment]::SetEnvironmentVariable("STRING_AI_API_KEY", "YOUR_API_KEY", "User")

# macOS / Linux
echo 'export STRING_AI_API_KEY="YOUR_API_KEY"' >> ~/.bashrc
source ~/.bashrc

Before you start, confirm you already have a working StringRoute sk- key. Replace YOUR_STRING_AI_API_KEY in the examples with your own key. Do not commit real keys to a repository or public docs.

Install Hermes Agent

Hermes Agent is a terminal coding agent. Use the official install script. Do not use third-party packages. The installer prepares its own runtime. You do not need to install Node.js first.

iex (irm https://hermes-agent.nousresearch.com/install.ps1)

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

The official site also offers desktop packages. Model setup still uses hermes model below. Do not pick a fixed menu number during installation.

Connect Hermes Agent

Hermes connects to StringRoute through the OpenAI-compatible API. Available models: gpt-6-astra, gpt-5.6-sol, gpt-5.6-luna.

Connection details

Stop the base URL at /v1. Do not append /chat/completions. Type the model name yourself, and make sure it matches the platform. Do not select by menu number. Those numbers change between versions.

Setup steps

1. In a new terminal, run hermes model.
2. Choose Custom endpoint. The menu may say Custom endpoint (self-hosted / VLLM / etc.). Choose it by name, not by a fixed number.
3. Fill in the base URL and API key from the table, and type the model name gpt-6-astra. If the wizard asks for API mode, choose Chat Completions.
4. Save, then run hermes.

You can also write the config file directly. This has the same effect as hermes model:

model:
  provider: custom
  default: gpt-6-astra
  base_url: https://www.string.llc/v1
  api_key: YOUR_STRING_AI_API_KEY
  api_mode: chat_completions

Available models can differ by account. You can confirm with:

curl https://www.string.llc/v1/models \
  -H "Authorization: Bearer YOUR_STRING_AI_API_KEY"

Verify the setup

In Hermes, send a simple message such as "Introduce yourself in one sentence." If it replies normally and StringRoute shows a matching usage record, the setup works.

Common issues

See Troubleshooting Quick Reference for more checks.

Before you start, confirm you already have a working StringRoute sk- key. Replace YOUR_STRING_AI_API_KEY in the examples with your own key. Do not commit real keys to a repository or public docs.

Install Cursor

This page covers the Cursor desktop app. Install it from the official download page. Do not use third-party packages.

Open the official Cursor download page and choose the installer for your system:

After installation, open Cursor and confirm you can reach the editor. The download page updates installers with each release, so always get the latest version from that page.

Cursor also has a terminal CLI (curl https://cursor.com/install -fsS | bash). This guide covers desktop Models / API Keys setup. The CLI is out of scope here.

Connect Cursor

Cursor connects to StringRoute through the OpenAI-compatible API. The recommended model is gpt-6-astra.

Connection details

Stop the Base URL at /v1. Do not append /chat/completions.

Setup steps

1. Open Cursor, click the settings icon in the bottom-left corner, then open Models in the sidebar.
2. Expand API Keys and enter your StringRoute API Key in the OpenAI API Key field.
3. Turn on Override OpenAI Base URL and enter https://www.string.llc/v1.
4. Select or manually add gpt-6-astra in the model list. The model name must match the platform. Available models can differ by account. You can confirm with:

curl https://www.string.llc/v1/models \
  -H "Authorization: Bearer YOUR_STRING_AI_API_KEY"

UI labels may change across Cursor versions. Use Models / API Keys as the source of truth.

Verify the setup

In Cursor, send a simple task:

Read the current project structure and summarize what this project may do. Do not modify files.

If Cursor replies normally and StringRoute shows a matching usage record, the setup works.

Common issues

See Troubleshooting Quick Reference for more checks.

Before you start, confirm you already have a working StringRoute sk- key. Replace YOUR_STRING_AI_API_KEY in the examples with your own key. Do not commit real keys to a repository or public docs.

Install DeepSeek Harness

Install it from the official site. Do not use third-party packages.

1. Open the DeepSeek Harness website.
2. Download the official desktop build for your system and finish installation. The site currently offers macOS (Apple silicon) and Windows (64-bit).
3. Open DeepSeek Harness and confirm you can reach the home screen.

You can also start the Web UI with the official command. Node.js is required.

If Node.js is not installed, finish Install the Node.js Runtime first.

npx @deepseek-ai/dsh web

The command prints a URL. Open it in a browser.

Connect DeepSeek Harness

DeepSeek Harness connects to StringRoute through a custom model API. Choose OpenAI Chat Completions from the official protocol list. Recommended models: deepseek-v4.1-flash and gpt-6-astra.

Do not choose OpenAI Responses or Anthropic Messages. Do not change the built-in OpenAI provider URL. A built-in provider's model list comes from the installed catalog, so it will not show the models StringRoute actually serves.

Connection details

The Provider ID must be lowercase and cannot be renamed after saving. To change it, add a new provider and delete the old one. Stop the endpoint at /v1. Do not append /chat/completions. The model name must match the platform.

Setup steps

1. Open Settings → Models.
2. Choose Add model provider, then switch the card to Custom model API.
3. Fill in the table above and add at least one model. You can choose Fetch available models. If that fails or the list is empty, enter the model ID by hand. That works the same way.
4. Save. Model changes apply on the next request. A restart is not required.
5. Click Choose workspace and select the project directory. You cannot send until a workspace is selected.
6. Select the new model in the model picker.

Available models can differ by account. You can confirm with:

curl https://www.string.llc/v1/models \
  -H "Authorization: Bearer YOUR_STRING_AI_API_KEY"

Verify the setup

Send a simple message such as "Introduce yourself in one sentence." If it replies normally and StringRoute shows a matching usage record, the setup works.

Common issues

Official docs: Use the Web UI, Configure models.

See Troubleshooting Quick Reference for more checks.

Before you start, confirm you already have a working StringRoute sk- key. Replace YOUR_STRING_AI_API_KEY in the examples with your own key. Do not commit real keys to a repository or public docs.

Install ZCode

This page covers the Z.ai ZCode desktop app. Download it from the official install page. Do not use third-party packages.

1. Open the ZCode install page.
2. Download the official installer for your system and finish installation. The page offers macOS (Apple Silicon / Intel), Windows (x64 / ARM64), and Linux (AppImage, DEB, RPM).
3. Open ZCode. On first launch, click Start using ZCode, then choose a project directory as the workspace.

On Windows, open it from the Start menu or the desktop shortcut. On macOS, drag ZCode.app into Applications, then open it from Launchpad.

Connect ZCode

ZCode connects to an OpenAI-compatible model service through a custom provider. Enter StringRoute here. Do not use a BigModel or Z.ai login instead.

Connection details

Stop the endpoint at /v1. Do not append /chat/completions. Do not enter https://www.string.llc (that address is for Claude Code). Leave the Anthropic endpoint empty. The model name must match the platform.

Setup steps

1. On the welcome page, choose Use API Key. If you are already in the main screen, click the model name in the chat box, then Manage Models at the bottom of the list, and open Settings → Model Settings.
2. At the bottom of the provider list, click Add Provider.
3. Set the name to StringRoute. If there is a separate OpenAI endpoint field, enter only https://www.string.llc/v1. If there is a single API base URL, enter the same address by hand. Do not pick the official OpenAI preset, which points to https://api.openai.com.
4. Enter the API Key and save.
5. Click Add Model, enter the model ID by hand, and turn on the enable switch.
6. Select the new model in the model picker.

Environment variables already set in a terminal are not synced into ZCode. Enter them in the screen above.

Available models can differ by account. You can confirm with:

curl https://www.string.llc/v1/models \
  -H "Authorization: Bearer YOUR_STRING_AI_API_KEY"

Verify the setup

Send a simple message such as "Introduce yourself in one sentence." If it replies normally and StringRoute shows a matching usage record, the setup works.

Common issues

Official docs: Install, Connect a model.

See Troubleshooting Quick Reference for more checks.

Before you start, confirm you already have a working StringRoute sk- key. Replace YOUR_STRING_AI_API_KEY in the examples with your own key. Do not commit real keys to a repository or public docs.

Install Dify

You can use official Dify Cloud or self-host Dify. This page only covers connecting StringRoute. It does not replace the official Dify deployment docs.

Option 1: Dify Cloud (recommended for first connection tests)

1. Open Dify Cloud and sign in.
2. After you enter a workspace, add a model provider with the steps below.

Option 2: Self-host

Your machine or server needs Docker and Docker Compose. See the Dify self-hosting docs for full requirements.

git clone --branch "$(curl -s https://api.github.com/repos/langgenius/dify/releases/latest | jq -r .tag_name)" https://github.com/langgenius/dify.git
cd dify/docker
cp .env.example .env
docker compose up -d

Open http://localhost/install to finish admin setup, then open http://localhost to enter Dify.

Connect Dify

Use the correct entry: Model Provider is for model access and is used in this guide. API Extension is for external HTTP middleware callbacks such as content review. It is not for model access. Do not enter the StringRoute address there.

Connection details

Setup steps

Go to Dify -> avatar in the top-right corner -> Settings -> Model Provider. Search for OpenAI-API-compatible, click Add Model, and fill in the table above.

Enable Vision, Function calling, and Stream based on the actual model capability. If unsure, keep defaults first, then click Add.

Available models can differ by account. You can confirm with:

curl https://www.string.llc/v1/models \
  -H "Authorization: Bearer YOUR_STRING_AI_API_KEY"

Verify the setup

1. Test the newly added model on the Model Provider page, or create a blank app and select that model.
2. Send a simple message such as "Introduce yourself in one sentence."
3. If Dify replies normally and StringRoute shows a matching usage record, the setup works.

Common issues

See Troubleshooting Quick Reference for more checks.

One API

This page builds and starts One API with Go. Node.js is not required.

Start One API

git clone https://github.com/songquanpeng/one-api.git
cd one-api
go build -o one-api
./one-api

Open http://localhost:3000. The default username and password are admin / 123456.

Add a Channel

Go to Channels -> Add Channel and choose Proxy:

Then create model mappings for gpt-6-astra, gpt-5.6-sol, and gpt-5.6-luna in model management.

Test

API_KEY="sk-one-api-key"
curl http://localhost:3000/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-6-astra", "messages": [{"role": "user", "content": "Hello"}]}'

Troubleshooting Quick Reference

This guide is for paid StringRoute API users. If you only use web chat, you do not need an API Key. Use Webchat directly.

Model Overview

StringRoute provides models for conversation, image generation, transcription, code review, and automation. Before integrating, confirm which models your account can access, then use the model ID in scripts or third-party tools.

Conversation Models

• gpt-6-astra: The latest flagship model, recommended as the default conversation model.
• gpt-5.6-sol: Flagship model for stable text generation, Q&A, and tool-calling workflows.
• gpt-5.6-luna: Lightweight and fast model for link testing, low-latency scripts, and cost-sensitive tasks.

Coding and Automation

• codex-auto-review: Automated code review model for code review workflows.

Image Capabilities

• gpt-image-1s: Image generation model.
• gpt-image-1.5: Image generation model.
• gpt-image-2: Recommended model for image generation and image editing.

Speech Transcription

• gpt-4o-transcribe: Speech-to-text model for audio transcription scenarios.

Query Available Models

Different accounts may have different model permissions. Use the model list endpoint to confirm which models your API Key can access:

curl https://www.string.llc/v1/models \
  -H "Authorization: Bearer YOUR_API_KEY"

If the API returns object: "list" and a data array, your API Key, Base URL, and network connection are basically working.