Last updated: 2026-04-20

Frameworks

Integrate SpendLil with popular web frameworks: Next.js, Express, FastAPI, Django, Rails, and more.

SpendLil uses provider-specific gateway subdomains. Your existing provider auth header (Authorization: Bearer, x-api-key, or x-goog-api-key) passes through unchanged — the official provider SDKs all work. You just point them at the gateway base URL and add one X-SpendLil-Key header. Below are copy-paste patterns for popular frameworks.

ℹ SDKs work out of the box

The OpenAI, Anthropic, and @ai-sdk/openai SDKs all support a custom baseURL plus default headers. LangChain, Vercel AI SDK, LlamaIndex, and most higher-level frameworks compose over these — no special proxy required.

Next.js

javascript app/api/chat/route.ts

import OpenAI from 'openai';
import { NextResponse } from 'next/server';

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: 'https://openai.gateway.spendlil.ai/v1',
  defaultHeaders: { 'X-SpendLil-Key': process.env.SPENDLIL_KEY },
});

export async function POST(req: Request) {
  const { message } = await req.json();
  const response = await client.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: message }],
  });
  return NextResponse.json({ reply: response.choices[0].message.content });
}

Express.js

javascript routes/ai.js

import { Router } from 'express';
import OpenAI from 'openai';

const router = Router();
const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: 'https://openai.gateway.spendlil.ai/v1',
  defaultHeaders: { 'X-SpendLil-Key': process.env.SPENDLIL_KEY },
});

router.post('/chat', async (req, res) => {
  const response = await client.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: req.body.message }],
  });
  res.json({ reply: response.choices[0].message.content });
});

export default router;

FastAPI (Python)

python main.py

import os
from fastapi import FastAPI
from pydantic import BaseModel
from openai import OpenAI

app = FastAPI()
client = OpenAI(
    api_key=os.environ['OPENAI_API_KEY'],
    base_url='https://openai.gateway.spendlil.ai/v1',
    default_headers={'X-SpendLil-Key': os.environ['SPENDLIL_KEY']},
)

class ChatRequest(BaseModel):
    message: str

@app.post('/chat')
async def chat(req: ChatRequest):
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': req.message}],
    )
    return {'reply': response.choices[0].message.content}

Django

python views.py

import os
import json
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from openai import OpenAI

client = OpenAI(
    api_key=os.environ['OPENAI_API_KEY'],
    base_url='https://openai.gateway.spendlil.ai/v1',
    default_headers={'X-SpendLil-Key': os.environ['SPENDLIL_KEY']},
)

@csrf_exempt
def chat(request):
    body = json.loads(request.body)
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': body['message']}],
    )
    return JsonResponse({'reply': response.choices[0].message.content})

Flask

python app.py

import os
from flask import Flask, request, jsonify
from openai import OpenAI

app = Flask(__name__)
client = OpenAI(
    api_key=os.environ['OPENAI_API_KEY'],
    base_url='https://openai.gateway.spendlil.ai/v1',
    default_headers={'X-SpendLil-Key': os.environ['SPENDLIL_KEY']},
)

@app.post('/chat')
def chat():
    data = request.get_json()
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': data['message']}],
    )
    return jsonify(reply=response.choices[0].message.content)

Ruby on Rails

ruby app/services/ai_client.rb

require 'net/http'
require 'json'

class AiClient
  def self.chat(message, model: 'gpt-4o-mini')
    uri = URI('https://openai.gateway.spendlil.ai/v1/chat/completions')
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true

    request = Net::HTTP::Post.new(uri)
    request['Authorization'] = "Bearer #{ENV['OPENAI_API_KEY']}"
    request['X-SpendLil-Key'] = ENV['SPENDLIL_KEY']
    request['Content-Type'] = 'application/json'
    request.body = {
      model: model,
      messages: [{ role: 'user', content: message }]
    }.to_json

    response = http.request(request)
    JSON.parse(response.body)
  end
end

Go

go main.go

package main

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

func main() {
	body, _ := json.Marshal(map[string]interface{}{
		"model": "gpt-4o-mini",
		"messages": []map[string]string{
			{"role": "user", "content": "Hello"},
		},
	})

	req, _ := http.NewRequest("POST",
		"https://openai.gateway.spendlil.ai/v1/chat/completions",
		bytes.NewBuffer(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("OPENAI_API_KEY"))
	req.Header.Set("X-SpendLil-Key", os.Getenv("SPENDLIL_KEY"))
	req.Header.Set("Content-Type", "application/json")

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

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	fmt.Println(result)
}

LangChain

python LangChain with the SpendLil gateway

import os
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model='gpt-4o-mini',
    api_key=os.environ['OPENAI_API_KEY'],
    base_url='https://openai.gateway.spendlil.ai/v1',
    default_headers={'X-SpendLil-Key': os.environ['SPENDLIL_KEY']},
)

response = llm.invoke('Hello from LangChain')
print(response.content)

Vercel AI SDK

typescript Vercel AI SDK with the SpendLil gateway

import { createOpenAI } from '@ai-sdk/openai';
import { generateText } from 'ai';

const openai = createOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: 'https://openai.gateway.spendlil.ai/v1',
  headers: { 'X-SpendLil-Key': process.env.SPENDLIL_KEY! },
});

const { text } = await generateText({
  model: openai('gpt-4o-mini'),
  prompt: 'Hello from Vercel AI SDK',
});