Quickstart

Before you start

Three steps to your first call. Nothing to request, no instance type to choose, and no need to care which silicon runs underneath.

1. Create an account. Sign up with an email and password on the registration page; a default key is generated for you.
2. Create an API key in the console. Open the API Key page in the console and add one. Keys can be organised per environment — production, staging, development — and disabled at any time.
3. Note the base_url. Point your SDK at the address below; every other parameter stays exactly as it is with the official SDK.

https://api.yrinvestment.net/v1

Authentication

Every endpoint uses HTTP Bearer auth: put the API key in the Authorization header. This matches OpenAI exactly, so the official SDKs attach it for you once api_key is set.

Authorization: Bearer sk-yr-3f8a1c2d7b4e5a90c1d2e3f4a5b6c7d8e9f0a1b2

Anatomy of a key

A key has two parts. The prefix is sk-yr- plus eight hex characters, which identifies the key; a random secret follows. The console and the call logs show only the prefix, so you can tell which key is in use.

The full key is shown once, at creation. Once the dialog closes it cannot be retrieved, so store it in a secret manager or an environment variable straight away. If it is lost, the only path is to disable the old key and create a new one.

Chat completions POST /v1/chat/completions

The endpoint you will use most. Semantics are identical to OpenAI Chat Completions. The platform dispatches the request, per the compatibility matrix and the routing policy, to silicon that can run the model and has capacity right now.

Request parameters

Example call

curl https://api.yrinvestment.net/v1/chat/completions \
  -H "Authorization: Bearer $YR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "DeepSeek-V4.1-Flash",
    "messages": [
      {"role": "system", "content": "You are a precise technical assistant."},
      {"role": "user", "content": "In one sentence, what problem does heterogeneous compute scheduling solve?"}
    ],
    "temperature": 0.6,
    "max_tokens": 512,
    "stream": false
  }'

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["YR_API_KEY"],
    base_url="https://api.yrinvestment.net/v1",  # change only this line
)

resp = client.chat.completions.create(
    model="DeepSeek-V4.1-Flash",
    messages=[
        {"role": "system", "content": "You are a precise technical assistant."},
        {"role": "user", "content": "In one sentence, what problem does heterogeneous compute scheduling solve?"},
    ],
    temperature=0.6,
    max_tokens=512,
)

print(resp.choices[0].message.content)
print(resp.usage.total_tokens)
print(resp.model_extra["yr_routing"])  # which silicon and which compute centre served this call

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.YR_API_KEY,
  baseURL: "https://api.yrinvestment.net/v1",
});

const resp = await client.chat.completions.create({
  model: "Qwen3-32B",
  messages: [
    { role: "system", content: "You are a precise technical assistant." },
    { role: "user", content: "In one sentence, what problem does heterogeneous compute scheduling solve?" },
  ],
  temperature: 0.6,
  max_tokens: 512,
});

console.log(resp.choices[0].message.content);
console.log(resp.usage.total_tokens);
console.log(resp.yr_routing);

Streaming

Set stream to true and the endpoint switches to Server-Sent Events: the response header is text/event-stream, the body is a series of data: lines, each one a JSON chunk, and the text delta sits in choices[0].delta.content. The final chunk carries finish_reason and usage, followed by data: [DONE].

data: {"id":"chatcmpl-8f2a1c7d4b9e0a3f5c6d","object":"chat.completion.chunk","created":1789243100,"model":"DeepSeek-V4.1-Flash","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}],"yr_routing":{"chip":"h200","chip_name":"H200","site":"HK-TKO","ttft_ms":180}}

data: {"id":"chatcmpl-8f2a1c7d4b9e0a3f5c6d","object":"chat.completion.chunk","created":1789243100,"model":"DeepSeek-V4.1-Flash","choices":[{"index":0,"delta":{"content":"Heterogene"},"finish_reason":null}]}

data: {"id":"chatcmpl-8f2a1c7d4b9e0a3f5c6d","object":"chat.completion.chunk","created":1789243100,"model":"DeepSeek-V4.1-Flash","choices":[{"index":0,"delta":{"content":"ous sched"},"finish_reason":null}]}

data: {"id":"chatcmpl-8f2a1c7d4b9e0a3f5c6d","object":"chat.completion.chunk","created":1789243100,"model":"DeepSeek-V4.1-Flash","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":42,"completion_tokens":168,"total_tokens":210}}

data: [DONE]

On the first chunk: yr_routing

A platform-specific extension field, present on the first streamed chunk (and at the top level of a non-streamed response). It tells you where the call actually landed — the silicon underneath is heterogeneous, but you never have to guess which card you got.

If the workload has hard requirements on jurisdiction or silicon family — domestic cards only, data must not leave the country — set a routing policy on the relevant key in the console, then use this field to verify it client-side.

stream = client.chat.completions.create(
    model="DeepSeek-V4.1-Flash",
    messages=[{"role": "user", "content": "Hello"}],
    stream=True,
)

for chunk in stream:
    routing = getattr(chunk, "yr_routing", None)
    if routing:
        print("served by", routing["chip_name"], "@", routing["site"])
    print(chunk.choices[0].delta.content or "", end="")

Model list GET /v1/models

Returns every model currently live, in the same shape as the OpenAI models endpoint: object is list, data is the model array, id is the model name you drop straight into the model field, and owned_by is the vendor. Use it to pull the selectable models at application start instead of hard-coding them.

curl https://api.yrinvestment.net/v1/models \
  -H "Authorization: Bearer $YR_API_KEY"

{
  "object": "list",
  "data": [
    { "id": "DeepSeek-V4.1-Flash", "object": "model", "owned_by": "DeepSeek", "created": 1756000000 },
    { "id": "Qwen3-32B",  "object": "model", "owned_by": "Qwen", "created": 1756000000 }
  ]
}

Which silicon families each model runs on, and what the evidence is, is set out in the compatibility matrix.

Rate limits & quota

Each API key carries three independent limits. They do not substitute for one another, and hitting any one of them rejects the request. The current level of all three is live in the console.

Error codes

Errors return JSON in a fixed shape: {"error": {"message": "...", "code": 401}}. message is written to be shown to an operator as-is, and code matches the HTTP status.