CORe API

The CORe API is a fully OpenAI-compatible REST API for CORe 6.2 and CORe 6.1. You can use any OpenAI SDK or HTTP client by pointing the base URL to https://opencore.one/v1.

Introduction #

The CORe API provides programmatic access to CORe's flagship language models. It follows the OpenAI API specification, meaning existing code written for OpenAI's API works with minimal changes.

All requests require authentication via a Bearer token. Responses are returned as JSON. Streaming (Server-Sent Events) is supported for real-time response delivery.

Quick Start #

1. Create an API key from the Dev Hub -- open your dashboard, click the Dev Hub card, then select API keys in the left sidebar and press Create API key. Copy the key immediately -- it is shown only once.
2. Set your base URL to https://opencore.one/v1 and authenticate with Authorization: Bearer <your-key>.
3. Send a request to /v1/chat/completions with your messages array.

Authentication #

Every API request must include an Authorization header with your API key:

Authorization: Bearer ck-your-api-key-here

API keys are prefixed with ck- and are 64-character hex strings. They are hashed (SHA-256) before storage -- only you ever see the raw key.

Rate Limits #

Rate limits depend on your account role. Untrusted users have hourly and daily caps. Trusted users get higher daily limits. Admins and Owners have unlimited access.

If you exceed a limit, the API returns HTTP 429 Too Many Requests with a Retry-After header indicating when you can resume.

GET /v1/models #

List all available models. Identical to the OpenAI /v1/models endpoint.

curl https://opencore.one/v1/models \
  -H "Authorization: Bearer ck-your-key-here"

{
  "object": "list",
  "data": [
    {
      "id": "core-ex2",
      "object": "model",
      "created": 1715000000,
      "owned_by": "core-technologies"
    },
    {
      "id": "core-pico-4",
      "object": "model",
      "created": 1714000000,
      "owned_by": "core-technologies"
    }
  ]
}

POST /v1/chat/completions #

The primary endpoint for chat completions. Accepts a conversation history and returns a model response. Supports both standard (blocking) and streaming (real-time) modes.

Request Body

The current lineup includes xenon-9, core-ex2, and core-pico-4. Both are available in the chat app and the API.

Response Format

Non-streaming response:

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1715000000,
  "model": "core-ex2",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 8,
    "total_tokens": 20
  }
}

Streaming (SSE)

When stream: true, the API returns Server-Sent Events. Each event is a JSON fragment containing a delta with partial content. The final event contains finish_reason.

The stream sends keep-alive comments during hidden reasoning. Treat a data: {"error":...} event as a failure, even if followed by [DONE]; interrupted generations are never reported as successful completions. Default server limits are 90 seconds without upstream data and 15 minutes total, including at max effort. Prefer streaming for long reasoning requests to avoid client or proxy timeouts.

While a model is reasoning, streaming responses may include short status summaries describing what the model is currently working on, wrapped in <sbegin>...</sbegin> markers. Once reasoning completes, the final reasoning content is an encrypted string. This is done on purpose.

curl https://opencore.one/v1/chat/completions \
  -H "Authorization: Bearer ck-your-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "core-ex2",
    "messages": [{"role": "user", "content": "Say hello"}],
    "stream": true
  }'

Multimodal Input (Image & Video)

Vision- and video-capable models accept the standard OpenAI multimodal content-parts format: the content field of a user message can be an array of parts, each part being text, image_url, or video_url.

Supported URL formats

• Public https:// URLs (recommended). The inference service fetches the URL server-side — the request body stays small and there's no per-message size cap beyond the media limits in the table below.
• data: URIs for inline base64 — e.g. data:image/jpeg;base64,... or data:video/mp4;base64,.... These travel inside the request body, so they're subject to the 8 MB body cap and only practical for small images. Host larger files publicly and pass the URL instead.

{
  "model": "xenon-9",
  "messages": [
    {
      "role": "user",
      "content": [
        { "type": "text", "text": "What's in this image?" },
        {
          "type": "image_url",
          "image_url": { "url": "https://example.com/photo.jpg" }
        }
      ]
    }
  ]
}

{
  "model": "xenon-9",
  "messages": [
    {
      "role": "user",
      "content": [
        { "type": "text", "text": "Summarize what happens in this video." },
        {
          "type": "video_url",
          "video_url": { "url": "https://example.com/clip.mp4" }
        }
      ]
    }
  ]
}

{
  "model": "xenon-9",
  "messages": [
    {
      "role": "user",
      "content": [
        { "type": "text", "text": "Compare this image to the video." },
        { "type": "image_url", "image_url": { "url": "https://example.com/a.jpg" } },
        { "type": "video_url", "video_url": { "url": "https://example.com/b.mp4" } }
      ]
    }
  ]
}

from openai import OpenAI

client = OpenAI(
    base_url="https://opencore.one/v1",
    api_key="ck-your-key-here",
)

response = client.chat.completions.create(
    model="xenon-9",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this video in one sentence."},
                {
                    "type": "video_url",
                    "video_url": {"url": "https://example.com/clip.mp4"},
                },
            ],
        }
    ],
)
print(response.choices[0].message.content)

Per-request limits

Each media URL is fetched server-side, so the URL-based caps are what matter in practice. Files over the per-item cap are replaced with a descriptive text marker so the model still sees a coherent prompt instead of a broken reference.

Accepted MIME types

• Images: image/jpeg, image/png, image/gif, image/webp
• Videos: video/mp4, video/webm, video/quicktime, video/x-m4v, video/mpeg, video/x-msvideo

Optional: image_url.detail

You can pass detail: "low" | "high" | "original" | "auto" alongside image_url.url to control preprocessing resolution. When in doubt, use auto. Higher detail produces more tokens and costs proportionally more.

Tool Calling

CORe 6.2 natively supports tool calling (function calling). Pass a tools array and optionally tool_choice to enable it.

{
  "model": "core-ex2",
  "messages": [{"role": "user", "content": "What's the weather?"}],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get weather for a location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": { "type": "string" }
          },
          "required": ["location"]
        }
      }
    }
  ],
  "tool_choice": "auto"
}

Available Models #

Error Handling #

The API uses standard HTTP status codes and returns JSON error bodies:

SDK Examples #

cURL

curl https://opencore.one/v1/chat/completions \
  -H "Authorization: Bearer ck-your-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "core-ex2",
    "messages": [{"role": "user", "content": "Hello"}],
    "stream": false
  }'

curl https://opencore.one/v1/chat/completions \
  -H "Authorization: Bearer ck-your-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "core-ex2",
    "messages": [{"role": "user", "content": "Count to 10"}],
    "stream": true
  }'

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://opencore.one/v1",
    api_key="ck-your-key-here",
)

response = client.chat.completions.create(
    model="core-ex2",
    messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)

for chunk in client.chat.completions.create(
    model="core-ex2",
    messages=[{"role": "user", "content": "Hello"}],
    stream=True,
):
    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://opencore.one/v1",
  apiKey: "ck-your-key-here",
  dangerouslyAllowBrowser: true,
});

const response = await client.chat.completions.create({
  model: "core-ex2",
  messages: [{ role: "user", content: "Hello" }],
});

console.log(response.choices[0].message.content);

const stream = await client.chat.completions.create({
  model: "core-ex2",
  messages: [{ role: "user", content: "Hello" }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}