API Documentation

Authorization: Bearer <YOUR_API_KEY>

const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-aihub-xxxxxxxxxxxxxxxxxxxx',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [{ role: 'user', content: 'Hello!' }],
  }),
});

const response = await fetch('https://api.aihub.io/v1/models', {
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
  },
});

const { data } = await response.json();
console.log(data); // Array of available models

// Use any model by its ID
const body = {
  model: 'anthropic/claude-3.5-sonnet', // or 'openai/gpt-4o', etc.
  messages: [{ role: 'user', content: 'Hello!' }],
};

const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [
      { role: 'system', content: 'You are a helpful assistant.' },
      { role: 'user',   content: 'Explain quantum computing in simple terms.' },
    ],
    temperature: 0.7,
    max_tokens: 1024,
  }),
});

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

const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [{ role: 'user', content: 'Tell me a short story.' }],
    stream: true,
  }),
});

const reader = response.body!.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const chunk = decoder.decode(value);
  const lines = chunk.split('\n').filter(line => line.startsWith('data: '));

  for (const line of lines) {
    const json = line.replace('data: ', '');
    if (json === '[DONE]') break;
    const parsed = JSON.parse(json);
    process.stdout.write(parsed.choices[0]?.delta?.content || '');
  }
}

const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [
      {
        role: 'user',
        content: [
          {
            type: 'text',
            text: 'What is in this image? Describe it in detail.',
          },
          {
            type: 'image_url',
            image_url: {
              url: 'https://example.com/photo.jpg',
              detail: 'high', // 'low' | 'high' | 'auto'
            },
          },
        ],
      },
    ],
    max_tokens: 1024,
  }),
});

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

const response = await fetch('https://api.aihub.io/v1/images/generations', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/dall-e-3',       // or 'stability/stable-diffusion-xl'
    prompt: 'A futuristic city at sunset, cyberpunk style, ultra-detailed, 8k',
    n: 1,                           // number of images (1–4)
    size: '1024x1024',              // '256x256' | '512x512' | '1024x1024' | '1792x1024' | '1024x1792'
    quality: 'hd',                  // 'standard' | 'hd'
    style: 'vivid',                 // 'vivid' | 'natural'
    response_format: 'url',         // 'url' | 'b64_json'
  }),
});

const data = await response.json();
console.log(data.data[0].url); // Image URL

// Text-to-Speech
const response = await fetch('https://api.aihub.io/v1/audio/speech', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/tts-1-hd',
    input: 'Hello! Welcome to AIHub, your unified AI gateway.',
    voice: 'nova',       // 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer'
    speed: 1.0,          // 0.25 – 4.0
    response_format: 'mp3', // 'mp3' | 'opus' | 'aac' | 'flac' | 'wav'
  }),
});

// Save audio to file
const buffer = await response.arrayBuffer();
fs.writeFileSync('output.mp3', Buffer.from(buffer));

// Send a PDF or document for analysis
const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'google/gemini-1.5-pro', // Models with large context windows work best
    messages: [
      {
        role: 'user',
        content: [
          { type: 'text', text: 'Summarize the key points of this document.' },
          {
            type: 'file',
            file: {
              url: 'https://example.com/report.pdf',
              mime_type: 'application/pdf',
            },
          },
        ],
      },
    ],
  }),
});

const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    // ── Core ──────────────────────────────────────────
    model: 'openai/gpt-4o',
    messages: [
      { role: 'system', content: 'You are a concise technical assistant.' },
      { role: 'user',   content: 'Explain REST APIs.' },
    ],

    // ── Sampling ──────────────────────────────────────
    temperature: 0.7,       // 0–2. Controls randomness. Default: 1
    top_p: 0.9,             // 0–1. Nucleus sampling. Default: 1
    top_k: 40,              // Integer. Top-K sampling (model-dependent)
    min_p: 0.05,            // Minimum probability threshold

    // ── Output length ─────────────────────────────────
    max_tokens: 2048,       // Max tokens to generate
    max_completion_tokens: 2048, // Alias for max_tokens (newer models)

    // ── Repetition control ────────────────────────────
    frequency_penalty: 0.3, // -2 to 2. Penalizes repeated tokens
    presence_penalty: 0.2,  // -2 to 2. Penalizes tokens already used
    repetition_penalty: 1.1, // >1 discourages repetition (some models)

    // ── Stop sequences ────────────────────────────────
    stop: ['###', '\n\n---'], // Stop generation at these strings

    // ── Streaming ─────────────────────────────────────
    stream: false,          // true = SSE streaming
    stream_options: {
      include_usage: true,  // Include token usage in final SSE chunk
    },

    // ── Reproducibility ───────────────────────────────
    seed: 42,               // Integer. Same seed = same output (best-effort)

    // ── Logprobs ──────────────────────────────────────
    logprobs: true,         // Return log probabilities
    top_logprobs: 5,        // Number of top tokens to return logprobs for

    // ── Response format ───────────────────────────────
    response_format: {
      type: 'json_object', // 'text' | 'json_object' | 'json_schema'
    },

    // ── Tools / Function calling ──────────────────────
    tools: [
      {
        type: 'function',
        function: {
          name: 'get_weather',
          description: 'Get current weather for a city',
          parameters: {
            type: 'object',
            properties: {
              city: { type: 'string', description: 'City name' },
              unit: { type: 'string', enum: ['celsius', 'fahrenheit'] },
            },
            required: ['city'],
          },
        },
      },
    ],
    tool_choice: 'auto', // 'none' | 'auto' | { type: 'function', function: { name: '...' } }
  }),
});

// Low temperature → focused, deterministic
const precise = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [{ role: 'user', content: 'What is 2 + 2?' }],
    temperature: 0.1,   // Near 0: very deterministic
  }),
});

// High temperature → creative, varied
const creative = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [{ role: 'user', content: 'Write a poem about the ocean.' }],
    temperature: 1.4,   // Higher: more creative and varied
  }),
}

const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer <YOUR_API_KEY>',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [{ role: 'user', content: 'Write a detailed essay on AI.' }],
    stream: true,
    stream_options: { include_usage: true }, // Get token count at the end
  }),
});

const reader = response.body!.getReader();
const decoder = new TextDecoder();
let fullText = '';

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  const lines = decoder.decode(value).split('\n');
  for (const line of lines) {
    if (!line.startsWith('data: ')) continue;
    const raw = line.slice(6);
    if (raw === '[DONE]') {
      console.log('\n\nStream complete. Full text:', fullText);
      break;
    }
    try {
      const chunk = JSON.parse(raw);
      const delta = chunk.choices?.[0]?.delta;

      if (delta?.content) {
        fullText += delta.content;
        process.stdout.write(delta.content); // Real-time output
      }

      // Final chunk includes usage when stream_options.include_usage = true
      if (chunk.usage) {
        console.log('\nTokens used:', chunk.usage);
      }
    } catch (_) { /* skip malformed lines */ }
  }
}

// Step 1: Send request with tools defined
const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [{ role: 'user', content: 'What is the weather in Paris right now?' }],
    tools: [{
      type: 'function',
      function: {
        name: 'get_weather',
        description: 'Returns current weather for a given city',
        parameters: {
          type: 'object',
          properties: {
            city: { type: 'string' },
            unit: { type: 'string', enum: ['celsius', 'fahrenheit'] },
          },
          required: ['city'],
        },
      },
    }],
    tool_choice: 'auto',
  }),
});

const data = await response.json();
const toolCall = data.choices[0].message.tool_calls?.[0];

if (toolCall) {
  const args = JSON.parse(toolCall.function.arguments);
  // Step 2: Execute your function
  const weatherResult = await getWeather(args.city, args.unit);

  // Step 3: Send result back to the model
  const followUp = await fetch('https://api.aihub.io/v1/chat/completions', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'openai/gpt-4o',
      messages: [
        { role: 'user', content: 'What is the weather in Paris right now?' },
        data.choices[0].message,
        {
          role: 'tool',
          tool_call_id: toolCall.id,
          content: JSON.stringify(weatherResult),
        },
      ],
    }),
  });
  const final = await followUp.json();
  console.log(final.choices[0].message.content);
}

const messages = [
  {
    role: 'system',
    content: `You are a senior TypeScript engineer. 
Rules:
- Always use strict TypeScript types, never use 'any'.
- Prefer functional patterns over classes.
- Keep responses concise and include code examples.
- If unsure, say so rather than guessing.`,
  },
  { role: 'user', content: 'How do I type a generic fetch wrapper?' },
];

// Reproducible generation
const body = {
  model: 'openai/gpt-4o',
  messages: [{ role: 'user', content: 'Give me a random number between 1 and 100.' }],
  seed: 42,
  temperature: 0,
};

// The system_fingerprint in the response tells you if the model changed
// { ..., "system_fingerprint": "fp_44709d6fcb" }

const response = await fetch('https://api.aihub.io/v1/chat/completions', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer <YOUR_API_KEY>', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'openai/gpt-4o',
    messages: [
      {
        role: 'system',
        content: 'You are a data extractor. Always respond with valid JSON.',
      },
      {
        role: 'user',
        content: 'Extract: name, email, and company from: "Hi, I am Alice (alice@acme.com) from Acme Corp."',
      },
    ],
    response_format: { type: 'json_object' },
    temperature: 0,
  }),
});

const data = await response.json();
const extracted = JSON.parse(data.choices[0].message.content);
// { name: "Alice", email: "alice@acme.com", company: "Acme Corp" }

{
  "id": "chatcmpl-abc123xyz",
  "object": "chat.completion",
  "created": 1720000000,
  "model": "openai/gpt-4o",
  "system_fingerprint": "fp_44709d6fcb",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "The meaning of life is a profound philosophical question...",
        "tool_calls": null,       // Populated when the model calls a tool
        "refusal": null           // Non-null if the model refused to answer
      },
      "logprobs": null,           // Populated when logprobs: true
      "finish_reason": "stop"     // See Finish Reasons section
    }
  ],
  "usage": {
    "prompt_tokens": 15,
    "completion_tokens": 87,
    "total_tokens": 102,
    "prompt_tokens_details": {
      "cached_tokens": 0,
      "audio_tokens": 0
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  }
}

// Each SSE chunk looks like:
data: {
  "id": "chatcmpl-abc123xyz",
  "object": "chat.completion.chunk",
  "created": 1720000000,
  "model": "openai/gpt-4o",
  "choices": [
    {
      "index": 0,
      "delta": {
        "role": "assistant",   // Only in the first chunk
        "content": "The "     // Incremental token(s)
      },
      "finish_reason": null    // null until the last chunk
    }
  ]
}

// ... more chunks ...

// Last content chunk:
data: {
  "choices": [{ "delta": { "content": "." }, "finish_reason": null }]
}

// Final chunk (finish_reason set):
data: {
  "choices": [{ "delta": {}, "finish_reason": "stop" }],
  "usage": { "prompt_tokens": 15, "completion_tokens": 87, "total_tokens": 102 }
}

// Stream end marker:
data: [DONE]

{
  "usage": {
    "prompt_tokens": 15,          // Tokens in your input (messages + system)
    "completion_tokens": 87,      // Tokens generated by the model
    "total_tokens": 102,          // prompt_tokens + completion_tokens

    // Detailed breakdown (newer models)
    "prompt_tokens_details": {
      "cached_tokens": 0,         // Tokens served from cache (billed at reduced rate)
      "audio_tokens": 0           // Audio input tokens
    },
    "completion_tokens_details": {
      "reasoning_tokens": 0,      // Internal reasoning tokens (o1 models)
      "audio_tokens": 0,
      "accepted_prediction_tokens": 0,
      "rejected_prediction_tokens": 0
    }
  }
}

// When the model decides to call a tool, finish_reason = "tool_calls"
{
  "id": "chatcmpl-abc123xyz",
  "object": "chat.completion",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc123",
            "type": "function",
            "function": {
              "name": "get_weather",
              "arguments": "{\"city\": \"Paris\", \"unit\": \"celsius\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": { "prompt_tokens": 82, "completion_tokens": 18, "total_tokens": 100 }
}

{
  "error": {
    "code": 401,
    "message": "Invalid API key. Please check your credentials.",
    "type": "authentication_error"
  }
}

try {
  const response = await fetch('https://api.aihub.io/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer <YOUR_API_KEY>',
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ model: 'openai/gpt-4o', messages: [...] }),
  });

  if (!response.ok) {
    const error = await response.json();
    console.error('API Error:', error.error.message);
    // Handle specific error codes
    if (response.status === 429) {
      console.log('Rate limit hit — please wait before retrying.');
    }
    return;
  }

  const data = await response.json();
  console.log(data.choices[0].message.content);
} catch (err) {
  console.error('Network error:', err);
}