Voke API Developer Guide

Overview

Voke API provides a standard REST API conforming 100% to the OpenAI Chat Completions specification. Any existing application or framework using official OpenAI SDKs, LangChain, LlamaIndex, LiteLLM, or Cursor can connect directly to Voke API by setting the baseURL and providing a Voke API key.

Quickstart SDKs

Choose your preferred language below. Simply point the official client to https://api.vokes.in/v1 and pass your Voke API key.

curl -X POST https://api.vokes.in/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $ANTHROPIC_API_KEY" \
  -d '{
    "model": "Fable 5.1",
    "messages": [
      {"role": "user", "content": "Explain quantum computing in three sentences."}
    ],
    "temperature": 0.7,
    "stream": false
  }'

from openai import OpenAI
import os

# Point standard OpenAI SDK to Voke API gateway
client = OpenAI(
    api_key=os.environ.get("ANTHROPIC_API_KEY"),
    base_url="https://api.vokes.in/v1"
)

response = client.chat.completions.create(
    model="Fable 5.1",
    messages=[
        {"role": "user", "content": "Explain quantum computing in three sentences."}
    ]
)

print(response.choices[0].message.content)

import OpenAI from 'openai';
// Drop-in replacement for OpenAI
const client = new OpenAI({
  apiKey: process.env.ANTHROPIC_API_KEY,
  baseURL: 'https://api.vokes.in/v1'
});

async function main() {
  const response = await client.chat.completions.create({
    model: 'Fable 5.1',
    messages: [{ role: 'user', content: 'Explain quantum computing in three sentences.' }],
    temperature: 0.7
  });

  console.log(response.choices[0].message.content);
}

main();

package main

import (
    "context"
    "fmt"
    "os"
    openai "github.com/sashabaranov/go-openai"
)

func main() {
    cfg := openai.DefaultConfig(os.Getenv("ANTHROPIC_API_KEY"))
    cfg.BaseURL = "https://api.vokes.in/v1"

    client := openai.NewClientWithConfig(cfg)
    resp, err := client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
            Model: "Fable 5.1",
            Messages: []openai.ChatCompletionMessage{
                {Role: openai.ChatMessageRoleUser, Content: "Explain quantum computing in three sentences."},
            },
        },
    )
    if err != nil {
        fmt.Printf("Error: %v\n")
        return
    }
    fmt.Println(resp.Choices[0].Message.Content)
}

Authentication

Voke API authenticates requests using API keys passed in the HTTP Authorization header:

Authorization: Bearer sk-ant-api03-GZ2Frr9uTFm0rt_mL71X_ULesqUUdlyyFWPIDH1ox2M

Base URL & Protocol

All API requests must be made over HTTPS. The production base URL is:

https://api.vokes.in/v1

Chat Completions API

Generate text and code completions given a list of conversation messages.

Request Body Parameters

Standard Response Format

{
"id": "chatcmpl-1a8eeff9-8d5c",
"object": "chat.completion",
"created": 1789312448,
"model": "Fable 5.1",
"choices": [
  {
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "Quantum computing uses qubits that exist in superpositions of 0 and 1."
    },
    "finish_reason": "stop"
  }
],
"usage": {
  "prompt_tokens": 16,
  "completion_tokens": 24,
  "total_tokens": 40
}
}

Server-Sent Event (SSE) Streaming

When stream: true is passed in the request body, Voke API streams chunks back in real-time as Server-Sent Events (SSE). Each chunk contains a delta object with incremental text tokens.

data: {"id":"chatcmpl-1a8e","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"Quantum"}}]}

data: {"id":"chatcmpl-1a8e","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":" computing"}}]}

data: [DONE]

Streaming in Python

stream = client.chat.completions.create(
    model="grok-4.6-fast",
    messages=[{"role": "user", "content": "Write a Python function to compute Fibonacci numbers."}],
    stream=True
)

for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    print(token, end="", flush=True)

Reasoning Models & Chain-of-Thought

Frontier reasoning models (like Fable 5.1, grok-4.6-fast, and gpt-oss-120b) output structured step-by-step thinking before providing the final answer.

During streaming, thought tokens are emitted via delta.reasoning_content, while the final response is streamed via delta.content:

// Phase 1: Thinking / Chain-of-Thought tokens
data: {"id":"chatcmpl-1","choices":[{"index":0,"delta":{"reasoning_content":"Let's calculate the factors..."}}]}

// Phase 2: Final response answer
data: {"id":"chatcmpl-1","choices":[{"index":0,"delta":{"content":"The answer is 42."}}]}

Supported Models

Voke API supports 12 frontier models across reasoning, agentic coding, and low-latency inference. Use any model ID directly in the model parameter:

Explore latency stats, benchmarks, and model logos on the interactive Models Explorer.

Rate Limits & Response Headers

All API responses include standard rate limit metadata headers:

Cursor & AI IDE Integration

You can use Voke API as your custom OpenAI provider in Cursor, Continue.dev, and Cline:

Error Codes & Handling

Voke API returns standard HTTP status codes and JSON error objects: