Vuto Lilt for developers
One model.
One clean contract.
OpenAI-compatible chat completions with JSON and SSE streaming, authenticated with a single bearer key.
Sign in to create and manage API keys in your console.
Everything you need to ship
Four things cover almost every integration. Each card jumps to the full reference.
Send a chat completion
POST one JSON request and get a complete reply back.
Stream a response
Read the reply as server-sent events instead of waiting for the full body.
Track usage & balance
Check prepaid balance and token counts for any request.
Handle errors
One error envelope and a fixed set of codes to check before you ship.
Conversational assistants
Chat interfaces backed by a single completions endpoint.
Support & help-desk bots
Draft first-line replies, or route and summarize incoming tickets.
Drafting and rewriting tools
Turn rough notes or transcripts into finished copy.
Chat backends for voice apps
Pair completions with your own speech layer for a spoken interface.
Start with the client you already use.
The API speaks the standard chat completions shape, so the OpenAI SDKs work by pointing
baseURL at Vuto and swapping in the model id below.
export VUTO_BASE_URL="https://talk.vuto.ai/v1"
export VUTO_API_KEY="paste_your_key_here"
curl "$VUTO_BASE_URL/chat/completions" \
-H "Authorization: Bearer $VUTO_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "vuto-lilt-01",
"messages": [
{"role": "user", "content": "Say hello in one sentence."}
]
}'import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://talk.vuto.ai/v1",
apiKey: process.env.VUTO_API_KEY
});
const completion = await client.chat.completions.create({
model: "vuto-lilt-01",
messages: [{ role: "user", content: "Say hello in one sentence." }]
});
console.log(completion.choices[0].message.content);import os
from openai import OpenAI
client = OpenAI(
base_url="https://talk.vuto.ai/v1",
api_key=os.environ["VUTO_API_KEY"],
)
completion = client.chat.completions.create(
model="vuto-lilt-01",
messages=[{"role": "user", "content": "Say hello in one sentence."}],
)
print(completion.choices[0].message.content)Authenticate every request.
Every /v1 endpoint, including GET /v1/models, requires a bearer key.
| Base URL | https://talk.vuto.ai/v1 |
|---|---|
| Model | vuto-lilt-01 |
| Header | Authorization: Bearer <your key> |
| Account | Sign in at /console to view balance and usage history. |
Keys are shown once, at creation, and can't be re-displayed. Call this API from a server you control, not directly from browser JavaScript: the API does not send CORS headers for cross-origin requests, and a bearer key placed in client-side code is visible to anyone who opens it.
Stream a response.
Set "stream": true and the response becomes
text/event-stream: a series of chat.completion.chunk
objects ending with data: [DONE].
A final chunk carries usage by default. Send
"stream_options": {"include_usage": false} to leave it out, or
{"include_usage": true} to make the request explicit. The official
OpenAI SDKs send that automatically from their .stream() helper.
stream_options on a request that isn't streaming returns
400 unsupported_parameter.
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://talk.vuto.ai/v1",
apiKey: process.env.VUTO_API_KEY
});
const stream = client.chat.completions.stream({
model: "vuto-lilt-01",
messages: [{ role: "user", content: "Say hello in one sentence." }]
});
stream.on("content.delta", ({ delta }) => process.stdout.write(delta));
const completion = await stream.finalChatCompletion();
console.log("\n" + completion.choices[0].message.content);import os
from openai import OpenAI
client = OpenAI(
base_url="https://talk.vuto.ai/v1",
api_key=os.environ["VUTO_API_KEY"],
)
with client.chat.completions.stream(
model="vuto-lilt-01",
messages=[{"role": "user", "content": "Say hello in one sentence."}],
) as stream:
for event in stream:
if event.type == "content.delta":
print(event.delta, end="", flush=True)
completion = stream.get_final_completion()
print("\n" + completion.choices[0].message.content)API reference
Three authenticated endpoints. Anything not documented here is not part of the contract.
Models
GET /v1/models
Lists the single public model identifier.
|
vuto-lilt-01 is Vuto's stable public model id. It is a transparent alias over the text model currently deployed behind it, not a claim of proprietary weights, and the id stays the same even if the underlying provider changes.
Chat completions
POST /v1/chat/completions
Generates a reply as JSON, or as an SSE stream when stream is
true. Request bodies over 262,144 bytes (256 KiB) are rejected with
413 request_too_large.
| Name | Type | Notes |
|---|---|---|
model Required |
string | Must be vuto-lilt-01, the id returned by GET /v1/models. |
messages Required |
array |
1 to 64 messages; combined message content up to 131,072 characters. Each message: |
stream Optional |
boolean | Default false. |
stream_options Optional |
object | { include_usage: boolean }. Only valid when stream is true. See Streaming. |
max_tokens / max_completion_tokens Optional |
integer | Aliases for the same value; if both are sent they must match. 1 to 8192, default 1024. |
temperature Optional |
number | 0 to 2. |
top_p Optional |
number | 0 to 1. |
stop Optional |
string or array | A string, or 1 to 4 strings, each ≤1024 characters. |
user Optional |
string | ≤512 characters. Hashed into an opaque per-caller identifier server-side; Vuto does not store or forward the raw value. |
Function calling (tools, tool_choice) is not available in
this beta. Any request key outside the table above, including tools,
tool_choice, n, response_format,
seed, logprobs, presence_penalty, and
frequency_penalty, returns 400 unsupported_parameter.
|
finish_reason is one of stop, length, tool_calls, or content_filter.
Usage
GET /v1/usage
Reads prepaid balance and today's recorded usage. day is always today in UTC and resets at UTC midnight.
|
The per-day totals (inputTokens, cachedInputTokens,
outputTokens, costMicrocredits, requests,
recent) use their internal camelCase names rather than the snake_case
used elsewhere in this response, reproduced above exactly as the API returns them.
recent holds up to the 20 most recent settled requests for the day,
newest first.
Errors
Every error, on every endpoint, uses the same envelope. Every response also carries an x-request-id header.
|
type is one of authentication_error, invalid_request_error,
rate_limit_error, insufficient_quota, provider_error,
or internal_error.
| Status | Code | When |
|---|---|---|
| 400 | invalid_parameter | A field failed validation. See param. |
| 400 | unsupported_parameter | An unknown or currently-unavailable field was sent. See param. |
| 400 | invalid_json | The request body is not valid JSON. |
| 401 | invalid_api_key | The bearer key is missing, malformed, or revoked. |
| 404 | model_not_found | model is not vuto-lilt-01. |
| 404 | not_found | The path is not one of the three /v1 endpoints. |
| 405 | method_not_allowed | Wrong HTTP method for a valid path. |
| 413 | request_too_large | Request body over 256 KiB. |
| 429 | rate_limit_exceeded | Per-key or platform request rate exceeded. Retry-After header is set. |
| 429 | insufficient_quota | Account balance can't cover the request's worst-case cost. |
| 429 | provider_rate_limited | The upstream model is temporarily rate limited. Retry. |
| 499 | request_aborted | The client disconnected before the response completed. |
| 502 | provider_error / invalid_provider_response / invalid_provider_usage / provider_response_too_large | The upstream model returned something Vuto couldn't validate. Retry. |
| 504 | provider_timeout | The upstream model did not respond within 60 seconds. |
| 500 | internal_error / accounting_error | An unexpected server-side failure. |
If a stream disconnects mid-response after the 200 status has already
been sent, Vuto ends it with an inline error chunk followed by
data: [DONE] rather than closing silently.
Rate limits & free keys
Current limits for the beta. All of these can change as the beta progresses.
Per-key request rate
Requests beyond this return 429 rate_limit_exceeded with a Retry-After header.
Platform-wide request rate
Shared across every key while the beta is capacity-limited.
Free key balance
Microcredits granted to the one free key issued per browser session.
Free keys per IP address
Beyond this, or beyond 100 issued platform-wide per day, requests return 429 with a Retry-After header.
Chat completion requests time out with 504 provider_timeout after 60 seconds without an upstream response.
Ready to test. Honest about the beta.
Create one Vuto key in the browser and use the live API immediately. Paid credit packs are not published yet.
- Keys
- Created once and shown once
- Balance
- Available from
/v1/usage - Billing
- One time trial credit only