VibeCode API

Send "stream": true to receive Server-Sent Events. Each chunk is a chat.completion.chunk, and the stream ends with data: [DONE].

The usage chunk is sent only if you ask for it with stream_options: {"include_usage": true}. Your bill does not depend on it: we count from the usage the model reports, and if those figures do not arrive, see How billing works.

curl -N https://api.vibecodeagent.my.id/v1/chat/completions \
  -H "Authorization: Bearer $VIBECODE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [{"role": "user", "content": "Tulis haiku tentang senja."}],
    "stream": true,
    "stream_options": {"include_usage": true}
  }'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.vibecodeagent.my.id/v1",
    api_key=os.environ["VIBECODE_API_KEY"],
)

stream = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Tulis haiku tentang senja."}],
    stream=True,
    stream_options={"include_usage": True},
)
for bagian in stream:
    if bagian.choices:
        print(bagian.choices[0].delta.content or "", end="", flush=True)
    if bagian.usage:
        print(f"\n[token: {bagian.usage.prompt_tokens} masuk, {bagian.usage.completion_tokens} keluar]")

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.vibecodeagent.my.id/v1",
  apiKey: process.env.VIBECODE_API_KEY,
});

const stream = await client.chat.completions.create({
  model: "deepseek-v4.1-flash",
  messages: [{ role: "user", content: "Tulis haiku tentang senja." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const bagian of stream) {
  const teks = bagian.choices?.[0]?.delta?.content;
  if (teks) process.stdout.write(teks);
  if (bagian.usage) {
    console.log(`\n[token: ${bagian.usage.prompt_tokens} masuk, ${bagian.usage.completion_tokens} keluar]`);
  }
}

Send function definitions in tools; the model replies with tool_calls. In streaming mode, arguments arrives in pieces with the same index, so join the pieces before parsing the JSON. Not every model supports function calling: try it first on the model you pick.

curl https://api.vibecodeagent.my.id/v1/chat/completions \
  -H "Authorization: Bearer $VIBECODE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4.1-flash",
    "messages": [{"role": "user", "content": "Cuaca di Bandung sekarang?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "cuaca_kota",
        "description": "Ambil cuaca terkini untuk satu kota.",
        "parameters": {
          "type": "object",
          "properties": {"kota": {"type": "string"}},
          "required": ["kota"]
        }
      }
    }]
  }'

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.vibecodeagent.my.id/v1",
    api_key=os.environ["VIBECODE_API_KEY"],
)

alat = [{
    "type": "function",
    "function": {
        "name": "cuaca_kota",
        "description": "Ambil cuaca terkini untuk satu kota.",
        "parameters": {
            "type": "object",
            "properties": {"kota": {"type": "string"}},
            "required": ["kota"],
        },
    },
}]

jawaban = client.chat.completions.create(
    model="deepseek-v4.1-flash",
    messages=[{"role": "user", "content": "Cuaca di Bandung sekarang?"}],
    tools=alat,
)
panggilan = jawaban.choices[0].message.tool_calls
if panggilan:
    print(panggilan[0].function.name, panggilan[0].function.arguments)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.vibecodeagent.my.id/v1",
  apiKey: process.env.VIBECODE_API_KEY,
});

const alat = [{
  type: "function",
  function: {
    name: "cuaca_kota",
    description: "Ambil cuaca terkini untuk satu kota.",
    parameters: {
      type: "object",
      properties: { kota: { type: "string" } },
      required: ["kota"],
    },
  },
}];

const jawaban = await client.chat.completions.create({
  model: "deepseek-v4.1-flash",
  messages: [{ role: "user", content: "Cuaca di Bandung sekarang?" }],
  tools: alat,
});
const panggilan = jawaban.choices[0].message.tool_calls;
if (panggilan) {
  console.log(panggilan[0].function.name, panggilan[0].function.arguments);
}

Send the function result back as a role: "tool" message with the same tool_call_id, as you would with OpenAI.

response_format is passed on to the model. {"type": "json_object"} works only on models that support it; other models may ignore it or reject it with a 400 upstream_rejected error. Ask for JSON in the prompt too, and check the result before you use it.

{
  "model": "deepseek-v4.1-flash",
  "messages": [{"role": "user", "content": "Beri tiga warna dasar sebagai objek JSON."}],
  "response_format": {"type": "json_object"}
}

The list below is read live from GET /v1/models, with no sign-in. Prices are in Credit per 1 million tokens.

Loading the model list…

A figure such as $0.292 Credit is VibeCode Credit, not US dollars.

The price you are billed is the same as in the app. Prices in the list already include the minimum rate: $0.025 Credit per 1 million input tokens and $0.05 Credit per 1 million output tokens.

GET /v1/models/{id} returns a single model; an id that is not available gets a 404 model_not_found.

curl https://api.vibecodeagent.my.id/v1/models

Errors are returned as an OpenAI-style error object, and the messages are in English:

{
  "error": {
    "message": "Invalid API key.",
    "type": "authentication_error",
    "param": null,
    "code": "invalid_api_key"
  }
}

Every response carries an x-request-id header; include it when you report a problem.

The limit is usually 20 requests per minute per account (a 60-second sliding window), counted across all of your keys; the figure for your account is shown in the Dashboard, under API Keys. Every chat response that passes the key check carries x-ratelimit-limit-requests, x-ratelimit-remaining-requests, and x-ratelimit-reset-requests.

Model capacity is shared with the VibeCode app. When it is full, your request queues for up to about 45 seconds; if it is still full, you receive a 429 capacity_exhausted. Follow the Retry-After header (in seconds) exactly as given: its value can be as low as 1 second.

With "stream": true, the model must start sending its answer within 30 seconds. Without stream, the whole answer must finish within 30 seconds; otherwise you receive a 502 upstream_error (we may retry first, so the total wait can be longer); use "stream": true for long answers.

• Each side (input and output) is rounded up to the smallest unit of Credit.
• Before the model runs, we reserve an estimated cost from your balance: input tokens are estimated from the size of the request (about 4 bytes per token), plus the output limit. When the request finishes, the difference is returned.
• If you do not set max_tokens or max_completion_tokens, we set an output limit as high as your balance can pay for, up to 32,768 tokens. A long answer may then end with finish_reason: "length"; set max_tokens yourself for long answers.
• If your balance is not enough for that estimate, the request is rejected with 402 before the model runs.
• Billing through the API never takes your balance below zero. If the actual cost exceeds the estimate and what is left cannot cover it, you are charged what the balance can pay; the excess is not billed.
• If the usage figures from the model do not arrive (e.g. the stream from the model is cut off), we bill according to the text already sent (about 4 bytes per token) and mark it "estimated" in the log.
• One short identity sentence (about 30 tokens) is added to your request so the model knows its name; it is billed as input tokens too.
• Request logs (without message content) are kept for 30 days; daily summaries remain stored. See them on the Credit page.
• If our server restarts exactly while your request is running, the balance reserved for that request can stay held. If your balance seems short, contact the VibeCode admin and mention the x-request-id.

Any tool that can use an "OpenAI compatible" endpoint works with three fields: the base URL https://api.vibecodeagent.my.id/v1, a sk-vc-… key, and a model id from the list. Menu names may differ between versions of a tool.

models:
  - name: VibeCode
    provider: openai
    model: deepseek-v4.1-flash
    apiBase: https://api.vibecodeagent.my.id/v1
    apiKey: sk-vc-...

• Do not put a key in public frontend code. This API allows requests from a browser on any origin (open CORS), so anyone who reads your page source can spend your balance.
• Keep keys in environment variables or a secrets store, one key per application.
• A leaked key: revoke it in the Dashboard, under API Keys. Revocation takes effect immediately, and the next request with that key is answered with 401.
• We never ask for your key by email or chat.
• The routes and tokens that the VibeCode app and web Chat use for your account are for those two only. Programmatic access to the models goes through this one route: a sk-vc-… key. Details are in the Terms of Service.