Rok temu miałem 4 aktywne subskrypcje AI. OpenAI API, Anthropic API, Google API, Groq. Każda z własnym billingiem, własną biblioteką, własnym rate limitem. Kiedy Anthropic miał problemy, mój produkt padał. Kiedy chciałem porównać modele, musiałem pisać 4 różne integracje.

Dziś używam OpenRouter. Jedno API, dostęp do 200+ modeli, jeden bill. Fallback między providerami automatyczny. Koszty spadły o 60% w porównaniu z direct API. I wybieram model per użycie, nie per projekt.

Ten post pokaże Ci, jak używam OpenRouter w produkcji, jaki model wybieram do jakich zadań i jak zbudować cost-effective AI stack.

Co to jest OpenRouter

OpenRouter to API aggregator dla modeli AI. Zamiast integrować z OpenAI, Anthropic, Google osobno, uderasz w jedno API. OpenRouter routuje request do właściwego providera.

Wygląda jak OpenAI API (kompatybilne endpointy). Zmieniasz base URL, mailer pracuje. Zero rewrite Twojego kodu.

Model wybierasz przez string:

  • openai/gpt-4o
  • anthropic/claude-sonnet-4-5
  • google/gemini-2.5-pro
  • meta-llama/llama-3.3-70b
  • mistralai/mistral-large

Plus 200 innych opcji.

Dlaczego to matter

Fallback. Anthropic ma outage? OpenRouter automatycznie routuje do OpenAI. Twój produkt nie pada.

Comparison. Chcesz porównać Claude vs GPT-4o na Twoim use case? Zmień jeden string, uruchom test.

Cost optimization. OpenRouter często oferuje pricing niższy niż direct providers. Plus batch discount, prompt caching optimization.

Rate limits pooling. OpenRouter agreguje rate limits. Nie trafisz w 429 na jednym providerze, jak Twój use case ma zmienny load.

Unified billing. Jeden invoice za wszystkie AI koszty. Prostsze księgowość, przewidywalne budżety.

Setup

Instalacja - literally kopiujesz OpenAI SDK config, zmieniasz base URL:

import OpenAI from 'openai'

const openai = new OpenAI({
  apiKey: process.env.OPENROUTER_API_KEY,
  baseURL: 'https://openrouter.ai/api/v1',
  defaultHeaders: {
    'HTTP-Referer': 'https://myapp.com',
    'X-Title': 'My App',
  },
})

const response = await openai.chat.completions.create({
  model: 'anthropic/claude-sonnet-4-5',
  messages: [{ role: 'user', content: 'Hello' }],
})

To wszystko. Jeśli używasz Vercel AI SDK, LangChain, LlamaIndex - wszystkie mają OpenRouter provider.

Model wybór: mój playbook

Konkretne modele do konkretnych zadań. Rok testów, iteracji, mierzenia.

Code generation, refactor, complex reasoning

Claude Sonnet 4.5. Best in class dla kodu w 2026. Rozumie kontekst, generuje kod, który się kompiluje.

Cena: $3/M input tokens, $15/M output tokens.

Kiedy: agentic workflows z kodem, complex refactors, architectural decisions.

Więcej o Claude w osobnym poście.

Chat, generał purpose

GPT-4o. Świetny do dialogów, konwersacji, ogólnej wiedzy. Trochę słabszy od Sonneta w kodzie, ale mocniejszy w narzędziach (image, voice).

Cena: $2.50/M input, $10/M output.

Kiedy: customer support chatboty, general knowledge Q&A, dialogi z użytkownikami.

Szybkie, tanie odpowiedzi

Gemini 2.5 Flash. Ultra fast, dramatycznie tańszy. Jakość dobra dla prostych zadań.

Cena: $0.10/M input, $0.40/M output.

Kiedy: klasyfikacja, extraction, summary, high-volume low-complexity.

Superintelligence dla najtrudniejszych zadań

Claude Opus 4.7 albo GPT-4.5. Reasoning, complex problems, deep analysis.

Cena: $15-20/M input, $60-100/M output. Drogo.

Kiedy: rzadkie użycie, gdy naprawdę potrzebujesz najlepszej jakości.

Local / private / offline

Llama 3.3 70B albo DeepSeek V3. Open weights, można self-host albo używać przez cheaper hosting (Groq, Together.ai).

Cena via OpenRouter: $0.60-0.90/M tokens.

Kiedy: sensitive data (fintech, medyczne), high volume batch processing.

Embedding (RAG)

OpenAI text-embedding-3-large (dla większości) albo Cohere embed-v3 (multilingual).

Cena: $0.13/M tokens (OpenAI), $0.10/M (Cohere).

Kiedy: RAG pipeline.

Router pattern: smart model selection

Zamiast jednego modelu dla wszystkiego, per-request wybór:

type TaskType = 'code' | 'chat' | 'classification' | 'reasoning' | 'batch'

function chooseModel(task: TaskType): string {
  switch (task) {
    case 'code':
      return 'anthropic/claude-sonnet-4-5'
    case 'chat':
      return 'openai/gpt-4o'
    case 'classification':
      return 'google/gemini-2.5-flash'
    case 'reasoning':
      return 'anthropic/claude-opus-4-7'
    case 'batch':
      return 'deepseek/deepseek-v3'
  }
}

W codebase piszesz:

const model = chooseModel('code')
const response = await openai.chat.completions.create({
  model,
  messages: [...],
})

Change model globalnie w jednym miejscu. Test nowego modelu przez zmianę stringa. Compare via A/B testy.

Cost optimization strategies

Rachunki za AI mogą wystrzelić. Konkretne techniki obniżania kosztów.

1. Prompt caching (killer feature)

Anthropic wspiera prompt caching. Za pierwszym razem pełna cena. Kolejne requesty z tym samym prefix: 90% zniżki.

Kiedy używać: długie system prompts (5000+ tokens), RAG z powtarzającym się kontekstem, agenci z długim context.

Setup w OpenRouter:

const response = await openai.chat.completions.create({
  model: 'anthropic/claude-sonnet-4-5',
  messages: [
    {
      role: 'system',
      content: [
        {
          type: 'text',
          text: hugeSystemPrompt,
          cache_control: { type: 'ephemeral' }
        }
      ]
    },
    { role: 'user', content: query }
  ],
})

Real savings: mój support agent (5000-token system prompt) obniżył koszty o 70% dzięki prompt caching.

2. Right-size the model

Klasyfikacja “spam/not spam” nie wymaga Claude Opus. Gemini Flash za $0.10/M tokens robi to samo.

Reguła: zacznij od najtańszego modelu, upgraduj tylko, jeśli jakość niewystarczająca.

Konkretnie:

  • Simple extraction/classification: Gemini Flash lub DeepSeek
  • Standard generation: GPT-4o mini lub Claude Haiku
  • Complex reasoning: Claude Sonnet lub GPT-4o
  • Hardest: Claude Opus (rzadko)

3. Streaming plus early termination

Chatboty często zwracają long responses. User widzi początek, wciska “stop”. Bez streaming płacisz za całą generation.

Ze streaming plus cancellation: klient odbiera fragment tokens, kancel, płacisz tylko za wygenerowaną część.

const stream = await openai.chat.completions.create({
  model: 'openai/gpt-4o',
  messages: [...],
  stream: true,
})

for await (const chunk of stream) {
  // process
  if (userCancelled) break
}

4. Batch API dla high volume

Non-real-time tasks (email classification, content analysis) można batchować.

Batch API (OpenAI, Anthropic): 50% zniżki, ale delivery w ciągu 24h zamiast sekundy.

Setup przez OpenRouter batch endpoint:

await openai.batches.create({
  input_file_id: fileId,
  endpoint: '/v1/chat/completions',
  completion_window: '24h',
})

Ideal dla nightly jobs, background processing.

5. Shorter prompts

Każdy token płacisz. Wywal zbędne słowa z system prompt.

Złe:

“You are a helpful AI assistant that helps users with their questions in a friendly and professional manner. Please make sure to always be polite and courteous when responding.”

Dobre:

“Answer user questions concisely and professionally.”

Save: 40 tokens. Times 100k requests: 4M tokens = $12 zaoszczędzone na Claude Sonnet.

6. Response length limits

Set max_tokens: 500 dla short responses. Bez tego model może generować 4000 tokens response.

7. Cache responses

Identyczne pytania (FAQ, common queries) cache’uj w Redis. Zero AI cost dla znanego pytania.

const cacheKey = hash(userQuery)
const cached = await redis.get(cacheKey)
if (cached) return cached

const response = await openai.chat.completions.create({ ... })
await redis.set(cacheKey, response, 'EX', 3600)

W typowym customer support 40-60% pytań powtarza się. Cache = 40-60% cost saving.

Cost tracking i budgety

Bez monitoring wydatków AI budżet ucieka.

OpenRouter dashboard: pokazuje koszty per model, per key, per day.

Set spending limits: max monthly spend per API key. Blokuje excess.

Alerts: Slack notification, jeśli daily spend > threshold.

Cost per feature: Loguj, ile kosztuje każdy AI feature w Twojej aplikacji. Pierwsze miesiące + iteracja.

Revenue per AI call: mierz, ile Ci przynosi kliknięcie/lead/conversion, który AI wygenerował. Cost:revenue ratio.

Fallback strategy

Real production wymaga fallback:

const models = [
  'anthropic/claude-sonnet-4-5',
  'openai/gpt-4o',
  'google/gemini-2.5-pro',
]

async function robustGenerate(prompt: string) {
  for (const model of models) {
    try {
      return await openai.chat.completions.create({
        model,
        messages: [{ role: 'user', content: prompt }],
        timeout: 10000,
      })
    } catch (err) {
      console.error(`${model} failed:`, err)
      continue
    }
  }
  throw new Error('All models failed')
}

Jeden provider fail, drugi bierze. User nie widzi outage.

OpenRouter vs direct API

Kiedy używać direct providera zamiast OpenRouter.

Direct lepsze dla:

  • Prompt caching direct od Anthropic ma najlepsze wsparcie (OpenRouter też ma, ale mniej dopracowane).
  • Beta features: nowe Anthropic features (thinking mode, tool_use) mogą być direct earlier niż na OpenRouter.
  • Enterprise contracts: negocjujesz discount z providerem bezpośrednio.
  • Fine-tuned models: własne fine-tunes zwykle tylko na direct API.
  • Wysoki volume, jeden model: uderasz w 100M tokens miesięcznie w jednym modelu, direct może być tańszy.

OpenRouter lepsze dla:

  • Multi-model experimentation
  • Fallback resiliency
  • Simpler infrastructure (jeden vendor)
  • Cost visibility (jeden bill)
  • Model swapping bez code changes

Dla mojej agencji: OpenRouter jako default. Direct API dla specyficznych klientów z high volume plus enterprise contract.

Prompt engineering per model

Modele reagują różnie na te same prompty. Nie zakładaj przenośności.

Claude: dobre reagują na strukturyzowane prompty (XML tags), explicit “think step by step”.

GPT-4o: bardziej “conversational”, lubi role-play framing, mniej wymaga strukturę.

Gemini: dobry w multi-modal (image + text), ale słabszy w following complex instructions.

Llama: wymaga more explicit context, mniej “reads between lines”.

Przy switching model, testuj prompty ponownie. Silver bullet nie istnieje.

Napisałem szerzej o promptowaniu dla programistów. Multi-model prompting to następny level tej dyscypliny.

Częste błędy

Jeden model dla wszystkiego. GPT-4o dla klasyfikacji spam. Za dużo płacisz. Router pattern.

Brak monitoring. Costs grow silently. Add dashboard od dnia 1.

Ignoring prompt caching. Long system prompt, każdy request full price. Włącz caching.

No fallback. Provider padnie, produkt padnie. Add fallback chain.

Testing na jednym modelu. Piszesz prompt na Claude, deploy na GPT-4o. Prompt nie działa. Test wszystkich, których używasz.

Streaming bez cancellation. User zamyka, generation trwa, płacisz. Cancel logic.

Ignoring rate limits. Burst traffic, dostajesz 429. Exponential backoff plus queue.

Compliance i privacy

Kilka considerations dla enterprise/EU projects.

Data residency. Twoje dane idą do serwerów. OpenRouter routuje do providerów. Providers mogą być w US.

Dla EU projektów z sensitive data: sprawdź, czy provider ma EU data residency (Anthropic EU, OpenAI EU option, Mistral EU).

Training on data. Niektóre providers używają Twoich API calls do trenowania. Sprawdź T&C.

  • OpenAI API: nie trenuje na Twoich datach (default).
  • Anthropic API: nie trenuje.
  • Google Gemini API: sprawdź toggle w console.

GDPR compliance: Data Processing Agreements dostępne dla enterprise plans.

HIPAA: OpenAI ma BAA. Anthropic dopracowuje. Fintech/healthcare mogą wymagać dedicated setup.

Co czytać dalej

  • OpenRouter docs. Krótkie, aktualne.
  • Simon Willison’s blog. Regularnie analizuje new models i pricing.
  • Artificial Analysis (artificialanalysis.ai). Cross-model benchmarks.

Nie kupuj kursów “AI mastery za 1000 zł”. Docs + experimentation = wystarczy.

Od czego zacząć

Jeśli używasz jednego direct API i myślisz o OpenRouter:

  1. Signup do OpenRouter. $10 credit dla nowych kont.
  2. Zmień base URL w istniejącym kodzie. 1 linia.
  3. Uruchom testy. Wszystko powinno działać.
  4. Porównaj costs month over month.
  5. Eksperymentuj z alternatywnymi modelami (cheaper for simple tasks).
  6. Add fallback dla resiliency.
  7. Po 3 miesiącach oceń: whether stayed with OpenRouter albo wrócić.

W mojej agencji OpenRouter to standard. Wszystkie nowe projekty startują na nim. Direct API tylko dla specyficznych wymagań klienta.

Pisałem osobno o AI agents i Fine-tuning vs RAG vs prompting. OpenRouter to infra layer, który spina wszystkie te tematy w productive stack.

Programista, który myśli o AI cost management, ma przewagę nad tym, który po prostu wywala rachunki OpenAI. W 2026 to jest core competency, nie ciekawostka.