Direct LLM Gateway

Every Wiro model, behind the API you already write against

One OpenAI-compatible endpoint. Change the base URL and your code keeps working: same SDK, same streaming, same tool calls, same retries. One project key pays for all of it.

Washttps://api.openai.com/v1

Nowhttps://llm.wiro.ai/v1

Go to docs Browse the models

Setup
One line
Protocols
Three
Credential
Your project key
Cost
In every response

What this is

If you have used OpenRouter or OrcaRouter, you already know the shape

One OpenAI-compatible endpoint in front of many models, reached with a single key and billed in one place. Wiro adds the part a router cannot: the models run on Wiro, beside the image, video and audio jobs your team already runs, under the same team policy and the same invoice.

no rewrite

Keep your SDK

The official OpenAI and Anthropic libraries work untouched. Twenty chat models answer today, from GPT, Claude, Grok and Seed families.

no surprises

You pick the model

Nothing reroutes your request to a cheaper model behind your back. You name it, that model answers, and the model ID never changes under you.

one invoice

One key for everything

The key that runs your video and image models runs your chat calls too. Every response carries what it cost, so there is nothing to reconcile later.

Getting started

Two minutes, one line

A Signature project sends YOUR_API_KEY:YOUR_API_SECRET. An API Key Only project sends just the key. Nothing else about your request changes.

// Node, official openai package
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.WIRO_KEY,
  baseURL: "https://llm.wiro.ai/v1",
});

const res = await client.chat.completions.create({
  model: "openai/gpt-5-6-sol",
  max_completion_tokens: 512,
  messages: [{ role: "user", content: "Hello" }],
});

# curl, same endpoint
curl https://llm.wiro.ai/v1/chat/completions \
  -H "Authorization: Bearer $WIRO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude/sonnet-5",
    "messages": [
      { "role": "user", "content": "What is SSE?" }
    ]
  }'

# See what your project can reach
curl https://llm.wiro.ai/v1/models \
  -H "Authorization: Bearer $WIRO_KEY"

Connect an agent

The tools your team already has open

Each one was installed and run against the gateway, tool calls and all. Pick yours and copy the setup.

CursorAdd custom models, override the OpenAI base URL, done. Claude CodeTwo environment variables in settings.json and it runs any model here. VS CodeBuilt-in Chat custom endpoint. No extension required. OpenAI SDKChat, Responses, streaming and tool loops on the official package. OpenClawOne provider block in openclaw.json, then the whole model list. HermesNous Research agent. Custom provider, four lines of YAML. WindsurfThrough an extension that takes a custom base, not through Cascade. Anything elseCline, Roo Code, Continue and the rest. If it takes a custom OpenAI or Anthropic base URL, it works here.

Go to docs

Start now

Change one base URL

Grab your project key, point your client at the gateway, keep the rest of your code. The reference has a copyable setup for every client above.

Go to docs See the models

Protocols

Three native protocols, no Wiro envelope to learn

Each route answers in its own protocol. An OpenAI SDK gets OpenAI chunks. An Anthropic SDK gets Anthropic events. Model IDs are lowercase owner/model.

Route	Protocol	Point your client at
`/v1/chat/completions`	OpenAI Chat	`https://llm.wiro.ai/v1`
`/v1/responses`	OpenAI Responses	`https://llm.wiro.ai/v1`
`/v1/messages`	Anthropic Messages	`https://llm.wiro.ai`, since those SDKs add `/v1`
`/v1/models`	Discovery	The models your project and team can reach
`/v1/files`	OpenAI and Anthropic Files	A view over your existing Wiro storage

What comes with it

Everything an agent loop needs

Not a text box with a model behind it. The pieces a real integration runs on, on every model that advertises them.

tools

Function calling

Standard tools and tool_choice. Wiro returns the calls, your client runs them, so execution stays inside your own trust boundary.

streaming

Server-sent events

Protocol-correct SSE on every route, including streamed tool-call arguments and a final usage frame when you ask for one.

structured

Typed output

json_object and strict json_schema, so extraction and classification pipelines get output they can parse.

multimodal

Images and documents in

Screenshot reasoning and document questions through the same chat call, on models that advertise those inputs.

reasoning

Reasoning controls

Effort levels and thinking budgets where a model supports them, with reasoning tokens counted in the usage you are billed for.

governance

Team access

Model discovery filtered to your team, spend limits that already apply, and per-call cost on every response.

Before you plan around it

What this deliberately does not do

Some of these are choices rather than gaps. Knowing them now costs less than finding them mid-integration.

No routing, no fallbackYou name the model and that model answers. Nothing silently substitutes a cheaper one, and there is no bring-your-own-provider-key execution.
Tools run on your sideNo provider-hosted web search, file search, code interpreter, computer use or remote MCP execution. Wiro hands you the tool call.
Text out, not mediaThese routes return text. Image, audio and video generation stay on the Run API. Image and document input is a different thing and is supported.
No embeddings or rerankingAnd no Gemini generateContent protocol, no legacy /v1/completions.
Streaming order, not live latencystream: true gives correct SSE ordering once the turn is persisted. Do not read first-event timing as provider token latency.
Async Run is still thereLong jobs keep their task id, WebSocket and callback on api.wiro.ai. The gateway sits beside that, not on top of it.

Task History

No tasks yet