Documentation

Pass your key in the Authorization: Bearer zpr-v1-... header. You can configure per-key USD credit caps, RPM rate limits, and IP allowlists in /app/keys

Pass any canonical model slug (such as openai/gpt-4o or anthropic/claude-3.7-sonnet). If the primary upstream endpoint returns a 5xx or rate-limit error before streaming begins, the gateway automatically fails over to the next healthy provider.

Pass stream: true to receive Server-Sent Events chunks ending with data: [DONE]. Include stream_options.include_usage = true to receive the final usage and exact USD cost object.

const stream = await client.chat.completions.create({
  model: 'openai/gpt-4o',
  stream: true,
  stream_options: { include_usage: true },
  messages: [{ role: 'user', content: 'Stream a haiku about distributed systems.' }],
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
  if (chunk.usage) {
    console.log('\nTokens & exact USD cost:', chunk.usage);
  }
}

Models with the tools capability accept standard OpenAI tools definitions and tool_choice controls for deterministic function calling.

const response = await client.chat.completions.create({
  model: 'openai/gpt-6.1-sol-pro',
  messages: [{ role: 'user', content: 'What is the exchange rate for USD to EUR?' }],
  tools: [
    {
      type: 'function',
      function: {
        name: 'get_fx_rate',
        description: 'Get live market exchange rate for a currency pair',
        parameters: {
          type: 'object',
          properties: {
            base: { type: 'string', enum: ['USD'] },
            quote: { type: 'string', enum: ['EUR', 'GBP', 'CHF'] },
          },
          required: ['base', 'quote'],
        },
      },
    },
  ],
  tool_choice: 'auto',
});

Enforce strict JSON schema compliance by passing response_format with type: json_schema or json_object on supported models.

const response = await client.chat.completions.create({
  model: 'google/gemini-2.5-pro',
  messages: [{ role: 'user', content: 'Extract invoice fields from: Invoice #904 for $25.00' }],
  response_format: {
    type: 'json_schema',
    json_schema: {
      name: 'invoice',
      strict: true,
      schema: {
        type: 'object',
        properties: {
          invoiceNumber: { type: 'string' },
          amountUsd: { type: 'number' },
        },
        required: ['invoiceNumber', 'amountUsd'],
        additionalProperties: false,
      },
    },
  },
});

For reasoning models (such as deepseek/deepseek-r1 or claude-3.7-sonnet), control thinking depth via reasoning_effort ('low' | 'medium' | 'high'). Reasoning tokens are metered and reported under completion_tokens_details.

const response = await client.chat.completions.create({
  model: 'deepseek/deepseek-r1',
  reasoning_effort: 'high',
  messages: [{ role: 'user', content: 'Prove that the square root of 2 is irrational.' }],
});

Every response includes x-ratelimit-limit, x-ratelimit-remaining, and x-ratelimit-reset headers. When a limit is reached, HTTP 429 is returned with a Retry-After header.

Before forwarding a request, the gateway places an atomic hold for the worst-case token cost and settles the exact nano-USD cost when the completion finishes. Query your live balance and generation costs via REST.

# Check API key limits & remaining budget
curl https://api.zopyr.com/v1/key \
  -H "Authorization: Bearer $ZOPYR_API_KEY"

# Check wallet balance & total usage
curl https://api.zopyr.com/v1/credits \
  -H "Authorization: Bearer $ZOPYR_API_KEY"

# Inspect exact token count, latency & settled cost for a generation
curl "https://api.zopyr.com/v1/generation?id=gen-0192a3b4..." \
  -H "Authorization: Bearer $ZOPYR_API_KEY"

By default, prompts and completions are never stored. Only request timing, token counts, and a monthly-salted IP hash are recorded. Opt-in content logging can be enabled per key and is encrypted with AES-256-GCM.

In addition to /v1/chat/completions, Zopyr natively serves the OpenAI 2026 Responses API, Anthropic Messages API (Claude Code compatible), vector Embeddings, encrypted organization Files, and stateful Realtime WebSockets under one API key.

const res = await fetch('https://api.zopyr.com/v1/responses', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${process.env.ZOPYR_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/gpt-6.1-sol-pro',
    instructions: 'Return concise engineering guidance.',
    input: 'Explain distributed circuit breaking in 3 bullets.',
    max_output_tokens: 512,
  }),
});
const data = await res.json();
console.log(data.output_text, data.usage);