OpenAI, modele i API dla deweloperów

OpenAI - Kompletny przewodnik po platformie AI, która zmieniła świat technologii

W listopadzie 2022 roku OpenAI wypuściło ChatGPT i w ciągu 5 dni zarejestrowało się ponad milion użytkowników. Dzisiaj wycena firmy sięga 852 miliardów dolarów, a jej produkty od GPT-5 przez DALL-E po Sora wyznaczają kierunek branży. Dla programisty OpenAI to jednak przede wszystkim platforma API z modelami, narzędziami i bibliotekami, na której buduje się własne aplikacje.

Czym jest OpenAI?

OpenAI to amerykańska firma badawczo-technologiczna zajmująca się sztuczną inteligencją, założona w grudniu 2015 roku przez Sama Altmana, Elona Muska, Ilyę Sutskevera, Grega Brockmana i innych. Początkowo działała jako organizacja non-profit z misją rozwijania "bezpiecznej i korzystnej" sztucznej inteligencji ogólnej (AGI).

Od 2019 roku OpenAI przeszło transformację strukturalną - z czystego non-profit na model hybrydowy z "ograniczonym zyskiem" (capped profit), a w 2025 roku przekształciło się w publiczną spółkę korzyści społecznych (PBC) pod nadzorem fundacji OpenAI Foundation. Ta ewolucja była napędzana prostym faktem: rozwój AI wymaga ogromnych zasobów obliczeniowych i finansowych.

Siedziba firmy mieści się w San Francisco. Jej CEO to Sam Altman, a firma zatrudnia tysiące pracowników i badaczy.

Historia i kluczowe momenty

2015-2018: Początki

OpenAI zostało założone z pledgem 1 miliarda dolarów od Altmana, Muska, Reida Hoffmana, Petera Thiela, AWS i innych. Celem było prowadzenie otwartych badań nad AI, stąd "Open" w nazwie. W 2018 roku Elon Musk opuścił zarząd po nieudanej próbie przejęcia kontroli nad organizacją.

2019-2022: GPT i przełom

W 2019 roku stworzono GPT-2, który zaskoczył jakością generowanego tekstu. GPT-3 (2020) z 175 miliardami parametrów zapoczątkował erę dużych modeli językowych. W 2021 pojawiły się DALL-E (generowanie obrazów) i Codex (generowanie kodu). GPT-3.5 i ChatGPT (listopad 2022) wywołały globalny boom AI.

2023: Turbulencje i GPT-4

W marcu 2023 OpenAI wypuściło GPT-4 - model multimodalny rozumiejący tekst i obrazy. W listopadzie zarząd usunął Sama Altmana ze stanowiska CEO. Pięć dni później wrócił, po tym jak praktycznie wszyscy pracownicy zagrozili odejściem. Kryzys doprowadził do rekonstrukcji zarządu.

2024-2025: Modele reasoning i GPT-5

OpenAI wprowadził serię modeli o1/o3/o4-mini z "myśleniem" - modele mogą rozumować krok po kroku przed udzieleniem odpowiedzi. W 2025 roku pojawił się GPT-5, unifikujący inteligencję ogólną, reasoning, kodowanie i multimodalność w jednej rodzinie modeli. Pojawiły się też Sora 2 (video), Operator (agent webowy), ChatGPT Atlas (przeglądarka) i GPT-OSS (modele open-weight).

W maju 2025 OpenAI przejęło za 6.5 miliarda dolarów firmę IO założoną przez Jony'ego Ive'a (byłego szefa designu Apple), planując stworzyć nową kategorię urządzeń osobistych.

31 marca 2026 roku firma zamknęła rundę finansowania na 122 miliardy dolarów, po której wycena sięgnęła 852 miliardów. Największe udziały objęli Amazon oraz Nvidia i SoftBank, a część rundy otwarto dla inwestorów indywidualnych. Przy takich kwotach warto pamiętać, że wycena nie mówi nic o stabilności cennika API, który zmieniał się w tym czasie kilkukrotnie.

Produkty OpenAI

ChatGPT

Flagowy produkt konsumencki OpenAI. Interfejs czatowy do interakcji z modelami GPT:

• ChatGPT Free - darmowy dostęp do GPT-4o mini
• ChatGPT Plus ($20/mies.) - GPT-4o, GPT-5, DALL-E, analiza danych
• ChatGPT Pro ($200/mies.) - nielimitowany dostęp do wszystkich modeli, o1-pro, deep research
• ChatGPT Team ($25/os./mies.) - wersja dla zespołów
• ChatGPT Enterprise - wersja korporacyjna z compliance i SSO

DALL-E / gpt-image

Modele generowania obrazów z opisów tekstowych. DALL-E 3 zintegrowane z ChatGPT. W 2025 roku OpenAI przeszło na modele gpt-image bazujące na multimodalnych możliwościach GPT, zastępując wcześniejsze modele dyfuzyjne.

Sora

Model text-to-video generujący filmy do rozdzielczości 1920x1080. Sora 2 (2025) oferuje ulepszoną symulację fizyki i zsynchronizowany dźwięk.

Whisper

Model rozpoznawania mowy - transkrypcja audio na tekst z obsługą wielu języków (w tym polskiego). Open-source, dostępny też przez API.

Operator

Agent AI do automatyzacji zadań w przeglądarce - logowanie, wypełnianie formularzy, nawigowanie po stronach.

Modele OpenAI dla deweloperów

Rodzina GPT-5

Cała trójka z linii 5.6 dzieli ten sam kontekst 1,05 miliona tokenów i limit wyjścia 128 tysięcy tokenów, a różni się poziomem możliwości i ceną. Myślnik w kolumnie kontekstu oznacza, że dokumentacja podaje tę wartość tylko dla bieżącej linii, więc dla starszych modeli sprawdź ją bezpośrednio w opisie modelu.

Rodzina GPT-4

Modele reasoning (seria O)

Modele O zużywają "reasoning tokens" na wewnętrzne myślenie - te tokeny są rozliczane jako output, ale nie widoczne w odpowiedzi API. Odpowiedź z 500 widocznymi tokenami może zużyć 2000+ tokenów.

Modele specjalistyczne

• gpt-image-1.5 - generowanie obrazów
• gpt-4o-transcribe / whisper-1 - transkrypcja audio
• gpt-4o-mini-tts - text-to-speech
• text-embedding-3-small/large - embeddingi tekstowe

Jak wybrać model?

• Prototypowanie: GPT-5 Nano lub GPT-4o Mini (najtańsze)
• Aplikacje ogólne: GPT-4o lub GPT-5
• Złożone rozumowanie: gpt-5.6-sol lub o3
• Kodowanie: GPT-4.1 (zoptymalizowany pod instrukcje)
• Masowe przetwarzanie: GPT-4o Mini + Batch API (50% taniej)

Responses API

Responses API to najnowsze API OpenAI, łączące prostotę Chat Completions z wbudowanymi narzędziami Assistants API. Zastępuje wcześniejsze Assistants API (deprecated, usunięcie w sierpniu 2026).

Podstawowe użycie

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4o",
    input="Wyjaśnij czym jest React w 3 zdaniach"
)
print(response.output_text)

Z wbudowanymi narzędziami

response = client.responses.create(
    model="gpt-4o",
    tools=[{"type": "web_search_preview"}],
    input="Jakie są najnowsze zmiany w Next.js 15?"
)
print(response.output_text)

Streaming

stream = client.responses.create(
    model="gpt-4o",
    input="Napisz tutorial o TypeScript generics",
    stream=True
)
for event in stream:
    if hasattr(event, "delta"):
        print(event.delta, end="", flush=True)

Chat Completions API

Klasyczne API do generowania odpowiedzi w formacie konwersacji:

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Jesteś pomocnym asystentem programisty."},
        {"role": "user", "content": "Jak stworzyć custom hook w React?"}
    ]
)
print(response.choices[0].message.content)

Structured Outputs

Wymuszenie odpowiedzi w określonym schemacie JSON:

from pydantic import BaseModel

class CodeReview(BaseModel):
    issues: list[str]
    suggestions: list[str]
    score: int

response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Przeanalizuj kod i zwróć review."},
        {"role": "user", "content": "function add(a,b){return a+b}"}
    ],
    response_format=CodeReview
)
review = response.choices[0].message.parsed
print(f"Score: {review.score}")
print(f"Issues: {review.issues}")

Function calling

Pozwala modelowi wywoływać zewnętrzne funkcje:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What's the weather in Warsaw?"}],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(f"Function: {tool_call.function.name}")
print(f"Args: {tool_call.function.arguments}")

Vision (analiza obrazów)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Co widzisz na tym zrzucie ekranu?"},
                {"type": "image_url", "image_url": {"url": "https://example.com/screenshot.png"}}
            ]
        }
    ]
)
print(response.choices[0].message.content)

Embeddingi

Embeddingi zamieniają tekst na wektory numeryczne, które odzwierciedlają znaczenie semantyczne. Podobne teksty generują podobne wektory.

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="TypeScript to nadzbiór JavaScriptu z typami statycznymi"
)
embedding = response.data[0].embedding
print(f"Wymiary: {len(embedding)}")

Zastosowania embeddingów

• Wyszukiwanie semantyczne - znajdowanie dokumentów po znaczeniu, nie słowach kluczowych
• RAG (Retrieval-Augmented Generation) - dostarczanie kontekstu do modeli
• Klasyfikacja - kategoryzowanie tekstów
• Rekomendacje - sugerowanie podobnych treści
• Wykrywanie anomalii - identyfikacja nietypowych wzorców

Porównanie modeli embeddingowych

Dla większości aplikacji text-embedding-3-small oferuje wystarczającą jakość przy 1/6 kosztu wersji large.

Agents SDK

Agents SDK to framework OpenAI do budowania agentów AI - programów, które mogą autonomicznie wykonywać wielokrokowe zadania, korzystając z narzędzi i delegując pracę innym agentom.

Podstawowy agent (Python)

from agents import Agent, Runner

agent = Agent(
    name="code-reviewer",
    instructions="You are an expert code reviewer. Analyze code for bugs, security issues, and performance problems.",
    model="gpt-4o"
)

result = Runner.run_sync(agent, "Review this function: def add(a,b): return a+b")
print(result.final_output)

Agent z narzędziami

from agents import Agent, Runner, function_tool

@function_tool
def search_docs(query: str) -> str:
    """Search project documentation"""
    return f"Found documentation about: {query}"

@function_tool
def run_tests(file_path: str) -> str:
    """Run tests for a specific file"""
    return f"All tests passed for {file_path}"

agent = Agent(
    name="dev-assistant",
    instructions="Help developers by searching docs and running tests.",
    tools=[search_docs, run_tests],
    model="gpt-4o"
)

result = Runner.run_sync(agent, "Check if the auth module has documentation and run its tests")
print(result.final_output)

Agents SDK (TypeScript)

import { Agent, run } from "@openai/agents"

const agent = new Agent({
  name: "assistant",
  instructions: "You are a helpful coding assistant.",
  model: "gpt-4o",
})

const result = await run(agent, "Explain React hooks")
console.log(result.finalOutput)

Handoffs (delegowanie)

Agenci mogą delegować zadania innym agentom:

from agents import Agent, Runner

researcher = Agent(
    name="researcher",
    instructions="Research topics thoroughly and provide detailed findings."
)

writer = Agent(
    name="writer",
    instructions="Write clear, engaging content based on research.",
    handoffs=[researcher]
)

result = Runner.run_sync(writer, "Write an article about WebAssembly")
print(result.final_output)

Wbudowane narzędzia

• web_search - wyszukiwanie w internecie
• file_search - przeszukiwanie dokumentów
• code_interpreter - wykonywanie kodu Python
• image_generation - generowanie obrazów
• computer_use - automatyzacja interfejsu

Codex CLI

Open-source narzędzie do agent-style kodowania w terminalu:

npx @openai/codex "Add error handling to the auth module"

Codex pracuje bezpośrednio z twoim repozytorium - czyta pliki, proponuje zmiany, pozwala je przejrzeć i zaakceptować. Integruje się z Agents SDK przez MCP (Model Context Protocol).

Optymalizacja kosztów

Prompt caching

OpenAI automatycznie cachuje powtarzające się prefiksy promptów:

Batch API

Dla zadań, które nie wymagają natychmiastowej odpowiedzi (analiza danych, generowanie treści):

batch = client.batches.create(
    input_file_id="file-abc123",
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

Batch API przetwarza żądania w ciągu 24 godzin z 50% rabatem.

Architektura kaskadowa

Efektywna strategia to routing żądań przez modele o rosnącej mocy:

1. GPT-4o Mini obsługuje 80% prostych zapytań ($0.15/1M input)
2. GPT-4o obsługuje 15% średnich zapytań ($2.50/1M input)
3. o3 obsługuje 5% złożonych zapytań ($2.00/1M input + reasoning)

Fine-tuning

Trenowanie modelu na własnych danych:

file = client.files.create(
    file=open("training_data.jsonl", "rb"),
    purpose="fine-tune"
)

job = client.fine_tuning.jobs.create(
    training_file=file.id,
    model="gpt-4.1-2025-04-14"
)

Fine-tuning jest dostępny dla GPT-4.1, GPT-4o i o4-mini. Koszt treningu: $1.50-$100/h w zależności od modelu.

SDK i biblioteki

Python

pip install openai

from openai import OpenAI

client = OpenAI()  # automatycznie czyta OPENAI_API_KEY z env

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}]
)

Node.js / TypeScript

npm install openai

import OpenAI from "openai"

const client = new OpenAI()

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello!" }],
})
console.log(response.choices[0].message.content)

.NET

dotnet add package OpenAI

REST API (curl)

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

Audio API

Transkrypcja (Speech-to-Text)

audio_file = open("meeting.mp3", "rb")
transcript = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",
    file=audio_file
)
print(transcript.text)

Text-to-Speech

response = client.audio.speech.create(
    model="gpt-4o-mini-tts",
    voice="alloy",
    input="TypeScript jest nadzbiorem JavaScriptu."
)
response.stream_to_file("output.mp3")

Generowanie obrazów

response = client.images.generate(
    model="gpt-image-1",
    prompt="A futuristic city with flying cars, cyberpunk style",
    size="1024x1024",
    n=1
)
print(response.data[0].url)

Bezpieczeństwo i prywatność

Polityka danych API

• Dane przesyłane przez API nie są używane do trenowania modeli (domyślnie)
• OpenAI przechowuje dane API przez 30 dni do monitoringu nadużyć
• Zero Data Retention (ZDR) dostępne dla kwalifikujących się klientów
• SOC 2 Type II compliance

Rate limits

Limity zależą od Tier użytkownika (Tier 1-5), który rośnie z wydatkami:

Klucze API

export OPENAI_API_KEY="sk-..."

Nigdy nie commituj kluczy API do repozytorium. Używaj zmiennych środowiskowych lub secret managers.

Porównanie z konkurencją

Tabela pokazuje stan na dzień publikacji i starzeje się szybciej niż cokolwiek innego w tym tekście. Ceny wejścia dotyczą najtańszego modelu w ofercie każdego dostawcy, a nie tego z pierwszego wiersza. Przed decyzją budżetową sprawdź stawki bezpośrednio u dostawcy, bo w tej branży zmieniają się w cyklu miesięcznym, a nie rocznym.

Praktyczna uwaga przy wyborze: publiczne zestawienia mierzą zadania, które rzadko przypominają Twoje. Zbuduj cienką warstwę z jednym interfejsem wywołań i porównaj dwóch dostawców na własnych danych. To jedyny test, który cokolwiek mówi. Jeśli dane nie mogą opuścić firmy, do porównania warto dorzucić model uruchamiany lokalnie przez Ollama, a przy budowaniu wielokrokowych przepływów ujednolicenie interfejsu daje LangChain.

Praktyczne zastosowania

Chatbot z kontekstem

messages = [
    {"role": "system", "content": "Jesteś asystentem sklepu internetowego. Odpowiadaj po polsku."},
    {"role": "user", "content": "Szukam butów do biegania w rozmiarze 43"}
]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages
)

messages.append(response.choices[0].message)
messages.append({"role": "user", "content": "A co z modelami wodoodpornymi?"})

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages
)

Analiza dokumentów z RAG

from openai import OpenAI
import numpy as np

client = OpenAI()

def get_embedding(text):
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=text
    )
    return response.data[0].embedding

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

docs = ["React to biblioteka do budowania UI", "Next.js to framework React z SSR"]
doc_embeddings = [get_embedding(d) for d in docs]

query_embedding = get_embedding("Jak renderować po stronie serwera?")
similarities = [cosine_similarity(query_embedding, de) for de in doc_embeddings]
best_doc = docs[np.argmax(similarities)]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": f"Odpowiedz na podstawie: {best_doc}"},
        {"role": "user", "content": "Jak renderować po stronie serwera?"}
    ]
)

Moderacja treści

response = client.moderations.create(
    model="omni-moderation-latest",
    input="Check this content for violations"
)
print(response.results[0].flagged)

FAQ

Ile kosztuje korzystanie z API OpenAI?

Opłaty są naliczane za tokeny (fragmenty tekstu). Najtańszy model (GPT-4.1 Nano) kosztuje $0.10/1M tokenów input. Nowe konta dostają darmowe kredyty na start.

Czym różnią się modele GPT od modeli O?

Modele GPT (GPT-4o, GPT-5) to modele ogólnego przeznaczenia - szybkie i wszechstronne. Modele O (o1, o3) to modele reasoning - "myślą" przed odpowiedzią, lepsze w złożonych problemach logicznych i matematycznych, ale wolniejsze i droższe.

Czy mogę fine-tunować modele OpenAI?

Tak, fine-tuning jest dostępny dla GPT-4.1, GPT-4o i o4-mini. Potrzebujesz danych treningowych w formacie JSONL.

Czy dane wysyłane do API są bezpieczne?

Dane API domyślnie nie są używane do trenowania modeli. OpenAI przechowuje je 30 dni do monitoringu. Dla wrażliwych danych dostępne jest Zero Data Retention.

Jak wybrać między OpenAI a alternatywami?

OpenAI ma najszerszy ekosystem narzędzi deweloperskich i najlepsze modele reasoning. Anthropic (Claude) wyróżnia się bezpieczeństwem i długim kontekstem. Google (Gemini) oferuje najdłuższy kontekst (2M) i integrację z GCP. Meta (Llama) to najlepsze modele open-source do samodzielnego hostingu.

Czy OpenAI ma modele open-source?

Tak, GPT-OSS (gpt-oss-120b i gpt-oss-20b) zostały wypuszczone w sierpniu 2025 pod licencją Apache 2.0.

Co to jest Responses API vs Chat Completions?

Responses API to nowsze API z wbudowanymi narzędziami (web search, file search, code interpreter). Chat Completions to starsze, prostsze API. OpenAI rekomenduje Responses API dla nowych projektów.

Czy ChatGPT i API to to samo?

Nie. ChatGPT to produkt konsumencki (aplikacja czatowa). API to usługa dla deweloperów do integracji modeli w własnych aplikacjach. Mają osobne plany cenowe.

Podsumowanie

OpenAI to lider w dziedzinie sztucznej inteligencji, oferujący najszerszy ekosystem narzędzi dla deweloperów - od modeli językowych i wizyjnych, przez SDK do budowania agentów, po narzędzia do fine-tuningu i embeddingów.

Dla deweloperów kluczowe są: Responses API jako główny punkt wejścia, Agents SDK do budowania wielokrokowych workflow'ów, Structured Outputs do typowanego wyjścia, function calling do integracji z zewnętrznymi serwisami, oraz bogata biblioteka modeli od najtańszych (GPT-4.1 Nano) po najpotężniejsze (o3, gpt-5.6-sol).

Niezależnie od tego, czy budujesz chatbota, system RAG, agenta AI czy pipeline przetwarzania danych - platforma OpenAI dostarcza narzędzia do realizacji praktycznie każdego zadania AI.

Jedna rzecz jest tu warta zapamiętania ponad wszystkie szczegóły: nazwy modeli i stawki zmieniają się w tej platformie szybciej niż treść jakiegokolwiek poradnika. Bieżącą listę modeli znajdziesz w dokumentacji OpenAI, a aktualne ceny na stronie cennika. Zanim zaszyjesz identyfikator modelu w kodzie, sprawdź te dwa adresy.