API Quickstart

set YOUROUTER_API_KEY=your-api-key-here

YOUROUTER_API_KEY=your-api-key-here

pip install requests

import os
import requests

response = requests.post(
    "https://api.yourouter.ai/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['YOUROUTER_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "gpt-4o",
        "messages": [
            {
                "role": "user",
                "content": "Reply with exactly: connected",
            }
        ],
    },
)

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

// Save as quickstart.mjs and run with Node.js 18+.

const response = await fetch('https://api.yourouter.ai/v1/chat/completions', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.YOUROUTER_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'gpt-4o',
    messages: [
      {
        role: 'user',
        content: 'Reply with exactly: connected',
      },
    ],
  }),
});

if (!response.ok) {
  throw new Error(await response.text());
}

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

package main

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

func main() {
	payload, _ := json.Marshal(map[string]any{
		"model": "gpt-4o",
		"messages": []map[string]string{
			{"role": "user", "content": "Reply with exactly: connected"},
		},
	})

	req, err := http.NewRequest(
		"POST",
		"https://api.yourouter.ai/v1/chat/completions",
		bytes.NewReader(payload),
	)
	if err != nil {
		panic(err)
	}

	req.Header.Set("Authorization", "Bearer "+os.Getenv("YOUROUTER_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	if res.StatusCode >= 400 {
		body, _ := io.ReadAll(res.Body)
		panic(fmt.Sprintf("request failed: %s\n%s", res.Status, body))
	}

	var result struct {
		Choices []struct {
			Message struct {
				Content string `json:"content"`
			} `json:"message"`
		} `json:"choices"`
	}

	if err := json.NewDecoder(res.Body).Decode(&result); err != nil {
		panic(err)
	}

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

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Quickstart {
    public static void main(String[] args) throws Exception {
        String body = String.join("\n",
            "{",
            "  \"model\": \"gpt-4o\",",
            "  \"messages\": [",
            "    {",
            "      \"role\": \"user\",",
            "      \"content\": \"Reply with exactly: connected\"",
            "    }",
            "  ]",
            "}"
        );

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.yourouter.ai/v1/chat/completions"))
            .header("Authorization", "Bearer " + System.getenv("YOUROUTER_API_KEY"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient().send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );

        if (response.statusCode() >= 400) {
            throw new RuntimeException(response.body());
        }

        System.out.println(response.body());
    }
}

<?php

$apiKey = getenv('YOUROUTER_API_KEY');

$payload = json_encode([
    'model' => 'gpt-4o',
    'messages' => [
        [
            'role' => 'user',
            'content' => 'Reply with exactly: connected',
        ],
    ],
]);

$ch = curl_init('https://api.yourouter.ai/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => $payload,
]);

$response = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);

if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}

curl_close($ch);

if ($status >= 400) {
    throw new RuntimeException($response);
}

$data = json_decode($response, true);
echo $data['choices'][0]['message']['content'] . PHP_EOL;

cargo add reqwest --features blocking,json
cargo add serde_json

use reqwest::blocking::Client;
use serde_json::json;
use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("YOUROUTER_API_KEY")?;

    let response: serde_json::Value = Client::new()
        .post("https://api.yourouter.ai/v1/chat/completions")
        .bearer_auth(api_key)
        .json(&json!({
            "model": "gpt-4o",
            "messages": [
                {
                    "role": "user",
                    "content": "Reply with exactly: connected"
                }
            ]
        }))
        .send()?
        .error_for_status()?
        .json()?;

    if let Some(content) = response["choices"][0]["message"]["content"].as_str() {
        println!("{content}");
    }

    Ok(())
}

npm install openai

import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.YOUROUTER_API_KEY,
  baseURL: 'https://api.yourouter.ai/v1',
});

const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    {
      role: 'user',
      content: 'Reply with exactly: connected',
    },
  ],
});

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

completion = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello from a pinned provider."}],
    extra_headers={"vendor": "openai"},
)

const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello from a pinned provider.' }],
}, {
  headers: { vendor: 'openai' },
});