OpenAI

Setup Your API Key

To use OpenAI with Orq.ai, follow these steps:

Navigate to AI Gateway > BYOK
Find OpenAI in the list
Click the Configure button next to OpenAI
In the modal that opens, select Setup your own API Key
Enter a name for this configuration (e.g., “OpenAI Production”)
Paste your OpenAI API Key into the provided field
Click Save to complete the setup

Your OpenAI API key is now configured and ready to use with Orq.ai in AI Studio or through the AI Gateway.

Available Models

The AI Gateway supports all current OpenAI models. Here are the most commonly used:

Recommended Models

Model	Context	Best For
`openai/gpt-5.6-sol`	1.05M	Complex professional work and agentic coding
`openai/gpt-5.6-terra`	1.05M	Balanced intelligence and cost for everyday work
`openai/gpt-5.6-luna`	1.05M	Fast, cost-efficient, high-volume workloads
`openai/gpt-5.4`	1.05M	Complex professional work
`openai/gpt-5.4-mini`	400K	Cost-efficient coding and visual reasoning

For a complete list of available OpenAI models, see Supported Models.

Choose a model based on the workload. Use openai/gpt-5.6-sol for complex work, openai/gpt-5.6-terra for balanced everyday work, or openai/gpt-5.6-luna for high-volume workloads.

Reasoning models (o1, o3, o4-mini) require developer mode enabled in your OpenAI account. Enable it in your account settings and accept the reasoning model terms before using these models.

Web Search

Add web search to Responses API calls with web_search_preview tools.

Reasoning models

Configure reasoning_effort for o1 and o3 models through the AI Gateway.

Quick Start

Access OpenAI’s GPT models through the AI Gateway.

curl -X POST https://api.orq.ai/v3/router/responses \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "input": "Explain quantum computing in simple terms"
  }'

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const response = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  input: "Explain quantum computing in simple terms",
});

console.log(response.output_text);

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    input="Explain quantum computing in simple terms",
)

print(response.output_text)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: "Explain quantum computing in simple terms",
    },
  ],
});

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

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

response = client.chat.completions.create(
    model="openai/gpt-5.6-sol",
    messages=[
        {
            "role": "user",
            "content": "Explain quantum computing in simple terms",
        }
    ],
)

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

Using the AI Gateway

Access OpenAI’s GPT models through the AI Gateway using the Responses API or Chat Completions, with streaming, function calling, and intelligent model routing. All OpenAI models are available with consistent formatting and automatic request logging.

OpenAI models use the provider slug format: openai/model-name. For example: openai/gpt-5.6-sol

Prerequisites

Before making requests to the AI Gateway, you need to configure your environment and install the SDKs if you choose to use them. Router Endpoint To use the AI Gateway with OpenAI models, configure your OpenAI SDK client with the base URL:

https://api.orq.ai/v3/router

Required Headers Include the following headers in all requests:

Authorization: Bearer $ORQ_API_KEY
Content-Type: application/json

Optional headers for advanced routing:

X-Orq-Provider: openai
X-Orq-Virtual-Key: your-virtual-key-name (optional)

Getting your API Key:

Go to API Keys
Click Create API Key and copy it
Store it in your environment as ORQ_API_KEY

SDK Installation Install the OpenAI SDK for your language:

npm install openai
# or
yarn add openai

pip install openai

If your OpenAI code is already functioning, you only need to change the base_url and api_key to the router endpoint and ORQ_API_KEY.

Basic Usage

Send messages to OpenAI models and get intelligent responses:

curl -X POST https://api.orq.ai/v3/router/responses \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "instructions": "You are a helpful assistant that explains complex concepts simply.",
    "input": "Explain machine learning"
  }'

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const response = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  instructions: "You are a helpful assistant that explains complex concepts simply.",
  input: "Explain machine learning",
});

console.log(response.output_text);

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    instructions="You are a helpful assistant that explains complex concepts simply.",
    input="Explain machine learning",
)

print(response.output_text)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [
    {
      role: "system",
      content: "You are a helpful assistant that explains complex concepts simply.",
    },
    {
      role: "user",
      content: "Explain machine learning",
    },
  ],
  temperature: 0.7,
  max_tokens: 500,
});

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

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

response = client.chat.completions.create(
    model="openai/gpt-5.6-sol",
    messages=[
        {
            "role": "system",
            "content": "You are a helpful assistant that explains complex concepts simply.",
        },
        {
            "role": "user",
            "content": "Explain machine learning",
        },
    ],
    temperature=0.7,
    max_tokens=500,
)

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

Function Calling

OpenAI models support function calling for structured interactions:

curl -X POST https://api.orq.ai/v3/router/responses \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "input": "What'\''s the weather in San Francisco?",
    "tools": [
      {
        "type": "function",
        "name": "get_weather",
        "description": "Get the current weather in a location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {
              "type": "string",
              "description": "The city and state, e.g. San Francisco, CA"
            },
            "unit": {
              "type": "string",
              "enum": ["celsius", "fahrenheit"]
            }
          },
          "required": ["location"]
        }
      }
    ]
  }'

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const response = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  input: "What's the weather in San Francisco?",
  tools: [
    {
      type: "function",
      name: "get_weather",
      description: "Get the current weather in a location",
      parameters: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "The city and state, e.g. San Francisco, CA",
          },
          unit: {
            type: "string",
            enum: ["celsius", "fahrenheit"],
          },
        },
        required: ["location"],
      },
    },
  ],
});

const toolCall = response.output.find((item) => item.type === "function_call");
if (toolCall?.type === "function_call") {
  console.log(`Calling function: ${toolCall.name}`);
  console.log(`Arguments: ${toolCall.arguments}`);
}

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    input="What's the weather in San Francisco?",
    tools=[
        {
            "type": "function",
            "name": "get_weather",
            "description": "Get the current weather in a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    ]
)

tool_call = next((item for item in response.output if item.type == "function_call"), None)
if tool_call:
    print(f"Calling function: {tool_call.name}")
    print(f"Arguments: {tool_call.arguments}")

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: "What's the weather in San Francisco?",
    },
  ],
  tools: [
    {
      type: "function",
      function: {
        name: "get_weather",
        description: "Get the current weather in a location",
        parameters: {
          type: "object",
          properties: {
            location: {
              type: "string",
              description: "The city and state, e.g. San Francisco, CA",
            },
            unit: {
              type: "string",
              enum: ["celsius", "fahrenheit"],
            },
          },
          required: ["location"],
        },
      },
    },
  ],
});

const toolCall = response.choices[0].message.tool_calls?.[0];
if (toolCall?.type === "function") {
  console.log(`Calling function: ${toolCall.function.name}`);
  console.log(`Arguments: ${toolCall.function.arguments}`);
}

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

response = client.chat.completions.create(
    model="openai/gpt-5.6-sol",
    messages=[
        {
            "role": "user",
            "content": "What's the weather in San Francisco?"
        }
    ],
    tools=[
        {
            "type": "function",
            "function": {
                "name": "get_weather",
                "description": "Get the current weather in a location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city and state, e.g. San Francisco, CA"
                        },
                        "unit": {
                            "type": "string",
                            "enum": ["celsius", "fahrenheit"]
                        }
                    },
                    "required": ["location"]
                }
            }
        }
    ]
)

tool_call = next(iter(response.choices[0].message.tool_calls or []), None)
if tool_call:
    print(f"Calling function: {tool_call.function.name}")
    print(f"Arguments: {tool_call.function.arguments}")

Tool Calling

Full reference for function tools, tool_choice, parallel calls, and streaming with tool calls through the AI Gateway.

Streaming

Stream responses for real-time output and improved user experience:

curl -X POST https://api.orq.ai/v3/router/responses \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "input": "Write a short poem about the ocean",
    "stream": true
  }'

curl -X POST https://api.orq.ai/v3/router/chat/completions \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "messages": [
      {
        "role": "user",
        "content": "Write a short poem about the ocean"
      }
    ],
    "stream": true
  }'

Using the Responses API

The Responses API combines the best of Chat Completions and Assistants APIs. Use responses.create() with the AI Gateway:

Web Search

Add web search to Responses API calls with web_search_preview tools.

Reasoning models

Use the reasoning object with o-series models on the Responses API.

Endpoint

POST https://api.orq.ai/v3/router/responses

Basic Usage

Configure the OpenAI SDK to use the AI Gateway and call the Responses API:

curl -X POST https://api.orq.ai/v3/router/responses \
  -H "Authorization: Bearer $ORQ_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "input": "Write a three sentence bedtime story about a unicorn"
  }'

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const stream = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  input: "Write a short poem about the ocean",
  stream: true,
});

for await (const event of stream) {
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  }
}

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

stream = client.responses.create(
    model="openai/gpt-5.6-sol",
    input="Write a short poem about the ocean",
    stream=True,
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ORQ_API_KEY,
  baseURL: "https://api.orq.ai/v3/router",
});

const stream = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [{ role: "user", content: "Write a short poem about the ocean" }],
  stream: true,
});

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

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("ORQ_API_KEY"),
    base_url="https://api.orq.ai/v3/router",
)

stream = client.chat.completions.create(
    model="openai/gpt-5.6-sol",
    messages=[{"role": "user", "content": "Write a short poem about the ocean"}],
    stream=True,
)

for chunk in stream:
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="", flush=True)

Automatic Request Logging

All requests made through the AI Gateway are automatically logged to your dashboard. You can view:

Request details: Model used, tokens, latency
Cost tracking: Per-request and aggregate costs
Error monitoring: Failed requests with error messages
Performance metrics: Response times and throughput

No additional configuration is needed. Logging happens automatically.

Troubleshooting

Issue	Problem	Solution
Rate Limiting	Too many requests to OpenAI API	Implement exponential backoff for retries. The AI Gateway automatically retries failed requests with appropriate delays.
High Latency	Slow response times	Monitor dashboard for model performance. Consider using `gpt-5.4-mini` for latency-sensitive applications.
Invalid Request Errors	Malformed API requests	Verify model name format (`openai/model-name`). Ensure required fields are present in messages array. Check that messages contain valid role values (user, assistant, system).
API Errors	HTTP errors from OpenAI	Handle errors with try/catch. Check error status codes and messages. Use the AI Gateway’s automatic retry mechanism.

Overview

Routing

Security & Privacy

Model Capabilities

Analytics & Monitoring

Integrations

Setup Your API Key

Available Models

Recommended Models

Web Search

Reasoning models

Quick Start

Using the AI Gateway

Prerequisites

Basic Usage

Function Calling

Tool Calling

Streaming

Using the Responses API

Web Search

Reasoning models

Endpoint

Basic Usage

Automatic Request Logging

Troubleshooting

Reference

​Setup Your API Key

​Available Models

​Recommended Models

Web Search

Reasoning models

​Quick Start

​Using the AI Gateway

​Prerequisites

​Basic Usage

​Function Calling

Tool Calling

​Streaming

​Using the Responses API

Web Search

Reasoning models

​Endpoint

​Basic Usage

​Automatic Request Logging

​Troubleshooting

​Reference

Setup Your API Key

Available Models

Recommended Models

Quick Start

Using the AI Gateway

Prerequisites

Basic Usage

Function Calling

Streaming

Using the Responses API

Endpoint

Basic Usage

Automatic Request Logging

Troubleshooting

Reference