curl https://proxy.WatchLLM.com/v1/chat/completions \
  -H "Authorization: Bearer lgw_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

import OpenAI from 'openai';
 
const openai = new OpenAI({
  apiKey: 'lgw_your_api_key_here', // Your WatchLLM key
  baseURL: 'https://proxy.WatchLLM.com/v1'
});
 
const response = await openai.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Hello!' }]
});
 
console.log(response.choices[0].message.content);

from openai import OpenAI
 
client = OpenAI(
    api_key='lgw_your_api_key_here',
    base_url='https://proxy.WatchLLM.com/v1'
)
 
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Hello!'}]
)
 
print(response.choices[0].message.content)

{
  "model": "gpt-4",
  "messages": [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Hello!"}
  ],
  "temperature": 0.7,
  "max_tokens": 100,
  "stream": false
}

{
  "id": "chatcmpl-xyz123",
  "object": "chat.completion",
  "created": 1234567890,
  "model": "gpt-4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hello! How can I help you today?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 15,
    "completion_tokens": 10,
    "total_tokens": 25
  },
  "x-WatchLLM-cached": false,
  "x-WatchLLM-cost-usd": "0.000625",
  "x-WatchLLM-latency-ms": 1847
}

const response = await fetch('https://proxy.WatchLLM.com/v1/chat/completions', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer lgw_xxx',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'gpt-4',
    messages: [{ role: 'user', content: 'Write a story' }],
    stream: true
  })
});
 
const reader = response.body.getReader();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(new TextDecoder().decode(value));
}

{
  "model": "gpt-3.5-turbo-instruct",
  "prompt": "Once upon a time",
  "max_tokens": 50,
  "temperature": 0.7
}

{
  "id": "cmpl-xyz123",
  "object": "text_completion",
  "created": 1234567890,
  "model": "gpt-3.5-turbo-instruct",
  "choices": [
    {
      "text": " there was a kingdom...",
      "index": 0,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 4,
    "completion_tokens": 50,
    "total_tokens": 54
  }
}

{
  "model": "text-embedding-ada-002",
  "input": "The quick brown fox jumps over the lazy dog"
}

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "embedding": [0.123, 0.456, ..., 0.789],
      "index": 0
    }
  ],
  "model": "text-embedding-ada-002",
  "usage": {
    "prompt_tokens": 8,
    "total_tokens": 8
  }
}

{
  "model": "text-embedding-ada-002",
  "input": [
    "First sentence",
    "Second sentence",
    "Third sentence"
  ]
}

{
  "status": "ok",
  "version": "1.0.0",
  "timestamp": "2024-12-12T10:30:00Z"
}

{
  "requests_total": 125000,
  "requests_today": 4200,
  "cache_hit_rate": 0.42,
  "cost_this_month": 87.50,
  "cost_saved": 62.30,
  "top_models": [
    {"model": "gpt-4", "requests": 80000, "cost": 65.00},
    {"model": "gpt-3.5-turbo", "requests": 45000, "cost": 22.50}
  ],
  "chart_data": [
    {"date": "2024-12-01", "requests": 3500, "cost": 2.80},
    {"date": "2024-12-02", "requests": 4100, "cost": 3.20}
  ]
}

{
  "projects": [
    {
      "id": "proj_abc123",
      "name": "My ChatGPT Wrapper",
      "provider": "openai",
      "created_at": "2024-01-15T10:00:00Z",
      "stats": {
        "requests_this_month": 50000,
        "cost_this_month": 45.00,
        "cache_hit_rate": 0.38
      }
    }
  ]
}

{
  "name": "Production App",
  "provider": "openai"
}

{
  "id": "proj_xyz789",
  "name": "Production App",
  "provider": "openai",
  "api_key": "lgw_proj_newkey123abc...",
  "created_at": "2024-12-12T10:30:00Z"
}

{
  "id": "proj_abc123",
  "name": "My ChatGPT Wrapper",
  "provider": "openai",
  "created_at": "2024-01-15T10:00:00Z",
  "api_keys": [
    {
      "id": "key_123",
      "name": "Production Key",
      "key": "lgw_proj_abc...",
      "last_used_at": "2024-12-12T09:45:00Z",
      "created_at": "2024-01-15T10:00:00Z"
    }
  ],
  "stats": {
    "requests_total": 125000,
    "requests_this_month": 50000,
    "cost_total": 450.00,
    "cost_this_month": 45.00,
    "cache_hit_rate": 0.38
  }
}

{
  "success": true,
  "message": "Project deleted"
}

{
  "name": "Staging Key"
}

{
  "id": "key_456",
  "name": "Staging Key",
  "key": "lgw_proj_newkey456def...",
  "created_at": "2024-12-12T10:30:00Z"
}

{
  "success": true,
  "message": "API key revoked"
}

{
  "logs": [
    {
      "id": "log_abc123",
      "model": "gpt-4",
      "tokens_used": 150,
      "cost_usd": 0.0045,
      "cached": false,
      "latency_ms": 2100,
      "created_at": "2024-12-12T10:30:00Z"
    },
    {
      "id": "log_def456",
      "model": "gpt-4",
      "tokens_used": 0,
      "cost_usd": 0,
      "cached": true,
      "tokens_saved": 150,
      "latency_ms": 45,
      "created_at": "2024-12-12T10:31:00Z"
    }
  ],
  "total": 2,
  "summary": {
    "total_requests": 2,
    "total_tokens": 150,
    "total_cost": 0.0045,
    "cache_hits": 1,
    "cache_hit_rate": 0.5
  }
}

date,model,tokens_used,cost_usd,cached,latency_ms
2024-12-12T10:30:00Z,gpt-4,150,0.0045,false,2100
2024-12-12T10:31:00Z,gpt-4,0,0,true,45

{
  "provider": "openai",
  "api_key": "sk-your-actual-openai-key"
}

{
  "success": true,
  "message": "Provider key updated",
  "provider": "openai"
}

{
  "success": true,
  "message": "Provider key removed"
}

{
  "plan": "pro",
  "billing_period": "monthly"
}

{
  "checkout_url": "https://checkout.stripe.com/c/pay/cs_xxx..."
}

{
  "portal_url": "https://billing.stripe.com/p/session/xxx..."
}

{
  "plan": "pro",
  "status": "active",
  "current_period_end": "2025-01-12T10:30:00Z",
  "cancel_at_period_end": false,
  "usage": {
    "requests_this_month": 500000,
    "plan_limit": 1000000,
    "percentage_used": 0.5
  }
}

{
  "type": "checkout.session.completed",
  "data": {
    "object": {
      "id": "cs_xxx",
      "customer": "cus_xxx",
      "subscription": "sub_xxx",
      "metadata": {
        "user_id": "user_abc123"
      }
    }
  }
}

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "You have exceeded your plan's rate limit",
    "details": {
      "plan": "starter",
      "limit": 60,
      "reset_at": "2024-12-12T10:31:00Z"
    }
  }
}

async function makeRequestWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await fetch(url, options);
    
    if (response.ok) return response;
    
    if ([502, 503, 429].includes(response.status)) {
      const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
      await new Promise(resolve => setTimeout(resolve, delay));
      continue;
    }
    
    throw new Error(`Request failed: ${response.status}`);
  }
  
  throw new Error('Max retries exceeded');
}

const response = await fetch('https://proxy.WatchLLM.com/v1/chat/completions', {
  /* ... */
});
 
if (response.status === 429) {
  const resetTime = response.headers.get('X-RateLimit-Reset');
  const waitSeconds = parseInt(resetTime) - Math.floor(Date.now() / 1000);
  
  console.log(`Rate limited. Retry in ${waitSeconds} seconds`);
  
  await new Promise(resolve => setTimeout(resolve, waitSeconds * 1000));
  // Retry request
}

npm install openai

import OpenAI from 'openai';
 
const client = new OpenAI({
  apiKey: process.env.WatchLLM_API_KEY,
  baseURL: 'https://proxy.WatchLLM.com/v1'
});
 
// Chat completion
const response = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Hello!' }]
});
 
// Streaming
const stream = await client.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Tell me a story' }],
  stream: true
});
 
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}

pip install openai

from openai import OpenAI
 
client = OpenAI(
    api_key=os.environ['WatchLLM_API_KEY'],
    base_url='https://proxy.WatchLLM.com/v1'
)
 
# Chat completion
response = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Hello!'}]
)
 
print(response.choices[0].message.content)
 
# Streaming
stream = client.chat.completions.create(
    model='gpt-4',
    messages=[{'role': 'user', 'content': 'Tell me a story'}],
    stream=True
)
 
for chunk in stream:
    print(chunk.choices[0].delta.content or '', end='')

curl https://proxy.WatchLLM.com/v1/chat/completions \
  -H "Authorization: Bearer $WatchLLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

curl https://proxy.WatchLLM.com/v1/embeddings \
  -H "Authorization: Bearer $WatchLLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "text-embedding-ada-002",
    "input": "Hello world"
  }'

import OpenAI from 'openai';
 
const client = new OpenAI({
  apiKey: process.env.WatchLLM_API_KEY,
  baseURL: 'https://proxy.WatchLLM.com/v1'
});
 
export default async function handler(req, res) {
  const { message } = req.body;
  
  const response = await client.chat.completions.create({
    model: 'gpt-4',
    messages: [{ role: 'user', content: message }]
  });
  
  res.json({ 
    reply: response.choices[0].message.content,
    cached: response.x_WatchLLM_cached,
    cost: response.x_WatchLLM_cost_usd
  });
}

go get github.com/sashabaranov/go-openai

package main
 
import (
	"context"
	"fmt"
	"os"
 
	"github.com/sashabaranov/go-openai"
)
 
func main() {
	config := openai.DefaultConfig(os.Getenv("WatchLLM_API_KEY"))
	config.BaseURL = "https://proxy.WatchLLM.com/v1"
 
	client := openai.NewClientWithConfig(config)
	resp, err := client.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: openai.GPT4,
			Messages: []openai.ChatCompletionMessage{
				{
					Role:    openai.ChatMessageRoleUser,
					Content: "Hello!",
				},
			},
		},
	)
 
	if err != nil {
		fmt.Printf("ChatCompletion error: %v\n", err)
		return
	}
 
	fmt.Println(resp.Choices[0].Message.Content)
}

gem install ruby-openai

require 'openai'
 
client = OpenAI::Client.new(
    access_token: ENV['WatchLLM_API_KEY'],
    uri_base: "https://proxy.WatchLLM.com/v1"
)
 
response = client.chat(
    parameters: {
        model: "gpt-4",
        messages: [{ role: "user", content: "Hello!" }],
        temperature: 0.7,
    }
)
 
puts response.dig("choices", 0, "message", "content")