Free OpenAI-Compatible API

ROK exposes a public, OpenAI-compatible chat completions API at https://rokremasteredapi.rokteam.org/v1. Point any OpenAI SDK client at it by changing base_url — requests and responses use the same schema as the OpenAI API.

• No authentication required. This endpoint is public by design — no API key or account required to use it.
• Native tool calling. tools and tool_choice are forwarded to the engine and tool_calls are surfaced in OpenAI format (streaming and non-streaming). It is a passthrough — your client runs the tools locally and sends results back as role: "tool" messages.
• Rate limited. 5 requests per minute per IP — excess requests return 429.

No authentication is required. The official OpenAI SDKs insist on a non-empty api_key, so pass any placeholder string — it is accepted and ignored server-side:

from openai import OpenAI

client = OpenAI(
    base_url="https://rokremasteredapi.rokteam.org/v1",
    api_key="unused",  # any non-empty string; not checked server-side
)

GET https://rokremasteredapi.rokteam.org/v1/models returns the list in the standard OpenAI shape ( {"object": "list", "data": [{id, object, created, owned_by}]} ):

An unknown model name is rejected with a 400 model_not_found error. Omitting model (or sending an empty string) silently defaults to rok-hermes.

Non-streaming request:

curl https://rokremasteredapi.rokteam.org/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "rok-hermes",
    "messages": [
      {"role": "user", "content": "Write a haiku about the ocean."}
    ]
  }'

Streaming request — the -Nflag disables curl's output buffering so chunks arrive as they are generated:

curl -N https://rokremasteredapi.rokteam.org/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "rok-hermes",
    "stream": true,
    "messages": [
      {"role": "user", "content": "Tell me a short joke."}
    ]
  }'

List available models:

curl https://rokremasteredapi.rokteam.org/v1/models

The official openai SDKs work identically to using real OpenAI — just point base_url at ROK.

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://rokremasteredapi.rokteam.org/v1",
    api_key="unused",
)

completion = client.chat.completions.create(
    model="rok-hermes",
    messages=[
        {"role": "user", "content": "Write a haiku about the ocean."}
    ],
)
print(completion.choices[0].message.content)

# Streaming works too:
stream = client.chat.completions.create(
    model="rok-hermes",
    messages=[{"role": "user", "content": "Tell me a joke."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://rokremasteredapi.rokteam.org/v1",
  apiKey: "unused",
});

const completion = await client.chat.completions.create({
  model: "rok-hermes",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(completion.choices[0].message.content);

POST https://rokremasteredapi.rokteam.org/v1/chat/completions — all fields except messages are optional.

With stream: true the response is a server-sent-event (SSE) stream of chat.completion.chunk objects. The first chunk carries the role; subsequent chunks carrydelta.content; a final chunk reports finish_reason; and the stream always terminates with data: [DONE].

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":1755461120,"model":"rok-hermes","choices":[{"index":0,"delta":{"role":"assistant","content":"Hello"},"finish_reason":null}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":1755461120,"model":"rok-hermes","choices":[{"index":0,"delta":{"content":" world"},"finish_reason":null}]}

data: {"id":"chatcmpl-...","object":"chat.completion.chunk","created":1755461120,"model":"rok-hermes","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: [DONE]

Pass stream_options: {"include_usage": true} to receive one final usage chunk ( "choices": [] with a usage field) just before [DONE].

Errors follow the OpenAI shape: {"error": {"message", "type", "param", "code"}}.

{
  "error": {
    "message": "The model 'gpt-4o' does not exist or is not accessible via this API. Available models: rok-hermes, rok-hermes-spicy.",
    "type": "invalid_request_error",
    "param": "model",
    "code": "model_not_found"
  }
}

429 responses include Retry-After (seconds until the window resets) plus X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset headers:

{
  "error": {
    "message": "Rate limit exceeded: 5 requests per minute per IP. Please slow down and retry.",
    "type": "rate_limit_error",
    "param": null,
    "code": "rate_limit_exceeded"
  }
}

The public API allows 5 requests per minute per IP. The client IP is taken from the CF-Connecting-IP header when present (ROK sits behind Cloudflare), falling back to the direct connection address — so the limit applies to the real caller, not a shared proxy.

• Requests beyond the limit are rejected with 429 rate_limit_error — the request is not queued, and the limit resets on a rolling per-minute window.
• Streaming counts as a single request regardless of how many chunks it produces.
• GET /v1/models is deliberately not rate limited — it returns a static list, so SDKs can probe it freely.