Language examples

Yaha Gateway works with OpenAI-compatible clients. Use these three values in every integration:

YAHA_BASE_URL="https://gateway.yahagateway.io/v1"
YAHA_API_KEY="yaha.YOUR_PROJECT_KEY"
YAHA_MODEL="gpt-4o-mini"

Replace YAHA_MODEL with a model returned by GET /v1/models. Keep YAHA_API_KEY server-side unless you are configuring a trusted local developer tool.

curl

curl "$YAHA_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $YAHA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "'"$YAHA_MODEL"'",
    "messages": [{ "role": "user", "content": "Hello from Yaha" }]
  }'

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: process.env.YAHA_BASE_URL,
  apiKey: process.env.YAHA_API_KEY,
});

const response = await client.chat.completions.create({
  model: process.env.YAHA_MODEL ?? "gpt-4o-mini",
  messages: [{ role: "user", content: "Hello from Yaha" }],
});

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

Python

import os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ["YAHA_BASE_URL"],
    api_key=os.environ["YAHA_API_KEY"],
)

response = client.chat.completions.create(
    model=os.getenv("YAHA_MODEL", "gpt-4o-mini"),
    messages=[{"role": "user", "content": "Hello from Yaha"}],
)

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

Go

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/openai/openai-go"
	"github.com/openai/openai-go/option"
)

func main() {
	client := openai.NewClient(
		option.WithBaseURL(os.Getenv("YAHA_BASE_URL")),
		option.WithAPIKey(os.Getenv("YAHA_API_KEY")),
	)

	resp, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
		Model: os.Getenv("YAHA_MODEL"),
		Messages: []openai.ChatCompletionMessageParamUnion{
			openai.UserMessage("Hello from Yaha"),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(resp.Choices[0].Message.Content)
}

Java

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

public class Main {
  public static void main(String[] args) {
    OpenAIClient client = OpenAIOkHttpClient.builder()
        .baseUrl(System.getenv("YAHA_BASE_URL"))
        .apiKey(System.getenv("YAHA_API_KEY"))
        .build();

    ChatCompletionCreateParams params = ChatCompletionCreateParams.builder()
        .model(ChatModel.of(System.getenv("YAHA_MODEL")))
        .addUserMessage("Hello from Yaha")
        .build();

    System.out.println(client.chat().completions().create(params).choices().get(0).message().content().orElse(""));
  }
}

C#

using OpenAI.Chat;

var credential = new System.ClientModel.ApiKeyCredential(
    Environment.GetEnvironmentVariable("YAHA_API_KEY")!
);

var options = new OpenAI.OpenAIClientOptions
{
    Endpoint = new Uri(Environment.GetEnvironmentVariable("YAHA_BASE_URL")!)
};

var client = new ChatClient(
    model: Environment.GetEnvironmentVariable("YAHA_MODEL") ?? "gpt-4o-mini",
    credential: credential,
    options: options
);

var response = client.CompleteChat("Hello from Yaha");
Console.WriteLine(response.Value.Content[0].Text);

PHP

<?php

$client = OpenAI::factory()
    ->withApiKey(getenv('YAHA_API_KEY'))
    ->withBaseUri(getenv('YAHA_BASE_URL'))
    ->make();

$response = $client->chat()->create([
    'model' => getenv('YAHA_MODEL') ?: 'gpt-4o-mini',
    'messages' => [
        ['role' => 'user', 'content' => 'Hello from Yaha'],
    ],
]);

echo $response->choices[0]->message->content;

Ruby

require "openai"

client = OpenAI::Client.new(
  access_token: ENV.fetch("YAHA_API_KEY"),
  uri_base: ENV.fetch("YAHA_BASE_URL")
)

response = client.chat(
  parameters: {
    model: ENV.fetch("YAHA_MODEL", "gpt-4o-mini"),
    messages: [{ role: "user", content: "Hello from Yaha" }]
  }
)

puts response.dig("choices", 0, "message", "content")

Rust

use async_openai::{
    config::OpenAIConfig,
    types::{ChatCompletionRequestUserMessageArgs, CreateChatCompletionRequestArgs},
    Client,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = OpenAIConfig::new()
        .with_api_base(std::env::var("YAHA_BASE_URL")?)
        .with_api_key(std::env::var("YAHA_API_KEY")?);

    let client = Client::with_config(config);
    let request = CreateChatCompletionRequestArgs::default()
        .model(std::env::var("YAHA_MODEL").unwrap_or_else(|_| "gpt-4o-mini".to_string()))
        .messages([ChatCompletionRequestUserMessageArgs::default()
            .content("Hello from Yaha")
            .build()?
            .into()])
        .build()?;

    let response = client.chat().create(request).await?;
    println!("{}", response.choices[0].message.content.as_deref().unwrap_or(""));
    Ok(())
}

Swift

import Foundation

let baseURL = ProcessInfo.processInfo.environment["YAHA_BASE_URL"]!
let apiKey = ProcessInfo.processInfo.environment["YAHA_API_KEY"]!
let model = ProcessInfo.processInfo.environment["YAHA_MODEL"] ?? "gpt-4o-mini"

let url = URL(string: "\(baseURL)/chat/completions")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try JSONSerialization.data(withJSONObject: [
    "model": model,
    "messages": [["role": "user", "content": "Hello from Yaha"]]
])

let (data, _) = try await URLSession.shared.data(for: request)
print(String(data: data, encoding: .utf8)!)

Kotlin

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody

val baseUrl = System.getenv("YAHA_BASE_URL")
val apiKey = System.getenv("YAHA_API_KEY")
val model = System.getenv("YAHA_MODEL") ?: "gpt-4o-mini"

val json = """
  {
    "model": "$model",
    "messages": [{ "role": "user", "content": "Hello from Yaha" }]
  }
""".trimIndent()

val request = Request.Builder()
  .url("$baseUrl/chat/completions")
  .addHeader("Authorization", "Bearer $apiKey")
  .addHeader("Content-Type", "application/json")
  .post(json.toRequestBody("application/json".toMediaType()))
  .build()

OkHttpClient().newCall(request).execute().use { response ->
  println(response.body?.string())
}

Dart

import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

Future<void> main() async {
  final baseUrl = Platform.environment['YAHA_BASE_URL']!;
  final apiKey = Platform.environment['YAHA_API_KEY']!;
  final model = Platform.environment['YAHA_MODEL'] ?? 'gpt-4o-mini';

  final response = await http.post(
    Uri.parse('$baseUrl/chat/completions'),
    headers: {
      'Authorization': 'Bearer $apiKey',
      'Content-Type': 'application/json',
    },
    body: jsonEncode({
      'model': model,
      'messages': [
        {'role': 'user', 'content': 'Hello from Yaha'}
      ],
    }),
  );

  print(response.body);
}

R

library(httr2)

base_url <- Sys.getenv("YAHA_BASE_URL")
api_key <- Sys.getenv("YAHA_API_KEY")
model <- Sys.getenv("YAHA_MODEL", "gpt-4o-mini")

response <- request(paste0(base_url, "/chat/completions")) |>
  req_headers(
    Authorization = paste("Bearer", api_key),
    "Content-Type" = "application/json"
  ) |>
  req_body_json(list(
    model = model,
    messages = list(list(role = "user", content = "Hello from Yaha"))
  )) |>
  req_perform()

resp_body_json(response)

PowerShell

$headers = @{
  Authorization = "Bearer $env:YAHA_API_KEY"
  "Content-Type" = "application/json"
}

$body = @{
  model = if ($env:YAHA_MODEL) { $env:YAHA_MODEL } else { "gpt-4o-mini" }
  messages = @(@{ role = "user"; content = "Hello from Yaha" })
} | ConvertTo-Json -Depth 5

Invoke-RestMethod `
  -Method Post `
  -Uri "$env:YAHA_BASE_URL/chat/completions" `
  -Headers $headers `
  -Body $body

For SDKs that support streaming, set stream: true or "stream": true in the request body. For raw HTTP clients, read the response as Server-Sent Events from /v1/chat/completions or /v1/responses.

{
  "model": "gpt-4o-mini",
  "stream": true,
  "messages": [{ "role": "user", "content": "Stream a short answer." }]
}

Reusable integration prompt

Paste this prompt into an AI coding assistant when adding Yaha Gateway to an existing application:

Integrate Yaha AI Gateway as the LLM provider for this application.

Use the OpenAI-compatible API contract:
- Base URL: read YAHA_BASE_URL from the environment, defaulting to https://gateway.yahagateway.io/v1.
- API key: read YAHA_API_KEY from the environment and send it as Authorization: Bearer <key>. The key starts with yaha.
- Model: read YAHA_MODEL from the environment and default to a model already allowed for the project.
- Primary endpoint: use /chat/completions unless the existing code already uses OpenAI Responses API semantics, in which case use /responses.
- Preserve existing streaming behavior by passing stream: true and consuming Server-Sent Events.
- Do not add provider API keys to the client application. Do not expose YAHA_API_KEY in browser code or mobile binaries unless this is a trusted local developer tool.
- Keep request and response shapes OpenAI-compatible. Only include routing fields such as models, route, or provider when the product explicitly needs fallback or provider preferences.
- Add a small smoke test or health check that calls GET /models with the Yaha key and verifies the configured model is available.

Make the smallest code change that reuses the existing LLM abstraction. Keep secrets in environment variables or the project secret manager.

Language Examples