Vuto

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.

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."}
    ]
  }'

Authenticate every request.

Every /v1 endpoint, including GET /v1/models, requires a bearer key.

Connection
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.
Note

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].

Note

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);

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.

Example response
{
  "object": "list",
  "data": [
    { "id": "vuto-lilt-01", "object": "model", "created": 0, "owned_by": "vuto" }
  ]
}

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.

Parameters
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: role (system, user, assistant, or tool), content (string, or null for an assistant message carrying tool_calls), optional name (≤64 characters), and tool_call_id (required, ≤128 characters, only on tool messages).

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.
Not supported yet

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.

Example response (stream: false)
{
  "id": "chatcmpl_9f4c2a5e6b7a4c1e9e2a5f3b7c8d1a90",
  "object": "chat.completion",
  "created": 1754297400,
  "model": "vuto-lilt-01",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Hello! How can I help today?" },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 9,
    "total_tokens": 21,
    "prompt_tokens_details": { "cached_tokens": 0 }
  }
}

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.

Example response
{
  "object": "usage.summary",
  "day": "2026-08-04",
  "unit": "microcredit",
  "balance_microcredits": 1487500,
  "rate_card": {
    "id": "private-beta-1",
    "applies_to": "new_requests",
    "input_microcredits_per_million_tokens": 1000000,
    "cached_input_microcredits_per_million_tokens": 250000,
    "output_microcredits_per_million_tokens": 4000000
  },
  "inputTokens": 812,
  "cachedInputTokens": 0,
  "outputTokens": 231,
  "costMicrocredits": 1735,
  "requests": 4,
  "recent": [
    {
      "requestId": "req_2f6a...",
      "model": "vuto-lilt-01",
      "status": "settled",
      "costMicrocredits": 612,
      "latencyMs": 940,
      "createdAt": "2026-08-04T10:02:11.000Z"
    }
  ]
}
Note

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.

Error envelope
{
  "error": {
    "message": "Invalid parameter.",
    "type": "invalid_request_error",
    "code": "invalid_parameter",
    "param": "temperature"
  }
}

type is one of authentication_error, invalid_request_error, rate_limit_error, insufficient_quota, provider_error, or internal_error.

Codes
Status Code When
400invalid_parameterA field failed validation. See param.
400unsupported_parameterAn unknown or currently-unavailable field was sent. See param.
400invalid_jsonThe request body is not valid JSON.
401invalid_api_keyThe bearer key is missing, malformed, or revoked.
404model_not_foundmodel is not vuto-lilt-01.
404not_foundThe path is not one of the three /v1 endpoints.
405method_not_allowedWrong HTTP method for a valid path.
413request_too_largeRequest body over 256 KiB.
429rate_limit_exceededPer-key or platform request rate exceeded. Retry-After header is set.
429insufficient_quotaAccount balance can't cover the request's worst-case cost.
429provider_rate_limitedThe upstream model is temporarily rate limited. Retry.
499request_abortedThe client disconnected before the response completed.
502provider_error / invalid_provider_response / invalid_provider_usage / provider_response_too_largeThe upstream model returned something Vuto couldn't validate. Retry.
504provider_timeoutThe upstream model did not respond within 60 seconds.
500internal_error / accounting_errorAn unexpected server-side failure.
Note

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.

60 / min

Per-key request rate

Requests beyond this return 429 rate_limit_exceeded with a Retry-After header.

600 / min

Platform-wide request rate

Shared across every key while the beta is capacity-limited.

1,500,000

Free key balance

Microcredits granted to the one free key issued per browser session.

5 / day

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
Feedback