Documentation - Oryxen AI

Get started in 5 simple steps

Setting up your Oryxen AI account is quick and straightforward. Follow these steps to generate your API key and start using our confidential computing platform.

Generate your API key

On the login page, click "Generate a new API key" to begin your secure setup.

Understand why security matters

Your mnemonic phrase and API key are the foundation of your account security—learn why they matter.

Secure your mnemonic

Receive your unique mnemonic phrase and a reminder to store it somewhere safe—this is your master backup.

Get your API key

Your API key is revealed for the first and only time—copy it immediately and store it securely.

Activate your account

Select your preferred plan, complete the payment, and your API key is instantly activated and ready to use.

Accessing Oryxen AI

Oryxen AI provides a simple, secure API and web chat interface. No software download required—just sign up, get your API key, and start building.

Web Chat

Use our secure, end-to-end encrypted web interface. No setup required—just sign in and start chatting.

Launch Web Chat →

API Integration

Build your own interface using our REST API. Full OpenAI-compatible endpoints with confidential computing guarantees.

View API Docs →

API Reference

Oryxen AI provides an OpenAI-compatible API that allows you to integrate our confidential computing platform with your existing applications and workflows. All API requests are processed inside hardware-isolated Trusted Execution Environments (TEEs), ensuring your data remains encrypted and secure at all times.

Endpoints

GET

/v1/models

List available models

POST

/v1/chat/completions

Create chat completion (OpenAI-compatible)

POST

/v1/completions

Create text completion (OpenAI-compatible)

POST

/v1/embeddings

Create embeddings (OpenAI-compatible)

GET

/v1/tokens

Check your remaining token balance

Base URL: https://api.oryxen.ai

Authentication: Bearer token in Authorization header

Content-Type: application/json

OpenAI Compatible: Drop-in replacement for OpenAI API endpoints

Code Examples

Python

JavaScript

cURL

Rust

Haskell

Julia

import requests

API_KEY = "your-api-key-here"
BASE_URL = "https://api.oryxen.ai/v1"

response = requests.post(
    f"{BASE_URL}/chat/completions",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "model": "oryxen-llm",
        "messages": [
            {"role": "user", "content": "Hello, how are you?"}
        ]
    }
)

print(response.json()["choices"][0]["message"]["content"])

const API_KEY = 'your-api-key-here';
const BASE_URL = 'https://api.oryxen.ai/v1';

const response = await fetch(`${BASE_URL}/chat/completions`, {
    method: 'POST',
    headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        model: 'oryxen-llm',
        messages: [
            { role: 'user', content: 'Hello, how are you?' }
        ]
    })
});

const data = await response.json();
console.log(data.choices[0].message.content);

curl https://api.oryxen.ai/v1/chat/completions \
  -H "Authorization: Bearer your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "oryxen-llm",
    "messages": [
      {"role": "user", "content": "Hello, how are you?"}
    ]
  }'

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

const API_KEY = "your-api-key-here"
const BASE_URL = "https://api.oryxen.ai/v1"

func main() {
    payload := map[string]interface{}{
        "model": "oryxen-llm",
        "messages": []map[string]string{
            {"role": "user", "content": "Hello, how are you?"},
        },
    }
    
    jsonData, _ := json.Marshal(payload)
    req, _ := http.NewRequest("POST", BASE_URL+"/chat/completions", bytes.NewBuffer(jsonData))
    req.Header.Set("Authorization", "Bearer "+API_KEY)
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result["choices"].([]interface{})[0].(map[string]interface{})["message"].(map[string]interface{})["content"])
}

use reqwest::Client;
use serde_json::json;

const API_KEY: &str = "your-api-key-here";
const BASE_URL: &str = "https://api.oryxen.ai/v1";

#[tokio::main]
async fn main() -> Result<(), Box> {
    let client = Client::new();
    
    let response = client
        .post(format!("{}/chat/completions", BASE_URL))
        .header("Authorization", format!("Bearer {}", API_KEY))
        .header("Content-Type", "application/json")
        .json(&json!({
            "model": "oryxen-llm",
            "messages": [{"role": "user", "content": "Hello, how are you?"}]
        }))
        .send()
        .await?;
    
    let data: serde_json::Value = response.json().await?;
    println!("{}", data["choices"][0]["message"]["content"]);
    
    Ok(())
}

{-# LANGUAGE OverloadedStrings #-}

import Network.HTTP.Simple
import Data.Aeson
import qualified Data.ByteString.Char8 as B

apiKey :: B.ByteString
apiKey = "Bearer your-api-key-here"

baseUrl :: String
baseUrl = "https://api.oryxen.ai/v1/chat/completions"

main :: IO ()
main = do
    let request = setRequestMethod "POST"
                $ setRequestHeader "Authorization" [apiKey]
                $ setRequestHeader "Content-Type" ["application/json"]
                $ setRequestBodyJSON payload
                $ parseRequest_ baseUrl
    
    response <- httpJSON request
    print (getResponseBody response :: Value)
  where
    payload = object ["model" .= "oryxen-llm",
                      "messages" .= [object ["role" .= "user", "content" .= "Hello!"]]]

using HTTP
using JSON3

const API_KEY = "your-api-key-here"
const BASE_URL = "https://api.oryxen.ai/v1"

headers = [
    "Authorization" => "Bearer $API_KEY",
    "Content-Type" => "application/json"
]

payload = Dict(
    "model" => "oryxen-llm",
    "messages" => [
        Dict("role" => "user", "content" => "Hello, how are you?")
    ]
)

response = HTTP.post(
    "$BASE_URL/chat/completions",
    headers,
    JSON3.write(payload)
)

data = JSON3.read(String(response.body))
println(data.choices[1].message.content)