How to Access Gemini Claude GPT 4o and DeepSeek With One API Call

# Add to your .env file
RBAOS_API_KEY=rbaos_your_api_key_here

const RBAOS_BASE = 'https://api.rbaos.com/v1';
const headers = {
  'Authorization': `Bearer ${process.env.RBAOS_API_KEY}`,
  'Content-Type': 'application/json'
};

async function callModel(model, userMessage) {
  const response = await fetch(`${RBAOS_BASE}/chat/completions`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      model,
      messages: [{ role: 'user', content: userMessage }],
      max_tokens: 500
    })
  });

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

// Call all four models with the same interface
const prompt = 'Explain the concept of recursion in two sentences.';

const results = await Promise.all([
  callModel('gemini-2.0-pro', prompt),
  callModel('claude-sonnet-4', prompt),
  callModel('gpt-4o', prompt),
  callModel('deepseek-r2', prompt)
]);

console.log('Gemini:', results[0]);
console.log('Claude:', results[1]);
console.log('GPT-4o:', results[2]);
console.log('DeepSeek:', results[3]);

import os
import httpx
import asyncio

RBAOS_BASE = 'https://api.rbaos.com/v1'
headers = {
    'Authorization': f'Bearer {os.environ["RBAOS_API_KEY"]}',
    'Content-Type': 'application/json'
}

async def call_model(client, model: str, message: str) -> str:
    response = await client.post(
        f'{RBAOS_BASE}/chat/completions',
        headers=headers,
        json={
            'model': model,
            'messages': [{'role': 'user', 'content': message}],
            'max_tokens': 500
        }
    )
    data = response.json()
    return data['choices'][0]['message']['content']

async def main():
    prompt = 'Explain recursion in two sentences.'
    models = ['gemini-2.0-pro', 'claude-sonnet-4', 'gpt-4o', 'deepseek-r2']

    async with httpx.AsyncClient() as client:
        tasks = [call_model(client, model, prompt) for model in models]
        results = await asyncio.gather(*tasks)

    for model, result in zip(models, results):
        print(f'{model}: {result}\n')

asyncio.run(main())

import OpenAI from 'openai';

// Before: pointed at OpenAI
// const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// After: pointed at RBAOS — now access every provider
const client = new OpenAI({
  apiKey: process.env.RBAOS_API_KEY,
  baseURL: 'https://api.rbaos.com/v1'
});

// Same SDK code, now routes to any provider
const claudeResponse = await client.chat.completions.create({
  model: 'claude-opus-4',
  messages: [{ role: 'user', content: 'Hello' }]
});

const geminiResponse = await client.chat.completions.create({
  model: 'gemini-2.0-ultra',
  messages: [{ role: 'user', content: 'Hello' }]
});

// Let RBAOS pick the best model based on your routing config
const response = await fetch(`${RBAOS_BASE}/chat/completions`, {
  method: 'POST',
  headers: {
    ...headers,
    'X-Task-Type': 'summarization',    // routing hint
    'X-Max-Cost-USD': '0.01'           // cost ceiling
  },
  body: JSON.stringify({
    model: 'auto',  // gateway selects the model
    messages: [{ role: 'user', content: 'Summarize: ' + longDocument }]
  })
});

async function callWithErrorHandling(model, messages) {
  try {
    const response = await fetch(`${RBAOS_BASE}/chat/completions`, {
      method: 'POST',
      headers,
      body: JSON.stringify({ model, messages })
    });

    if (!response.ok) {
      const error = await response.json();
      // RBAOS returns normalized error codes regardless of which provider failed
      console.error('API error:', error.error.code, error.error.message);
      throw new Error(error.error.message);
    }

    return await response.json();
  } catch (error) {
    console.error('Request failed:', error.message);
    throw error;
  }
}