ChatGPT API Python: полный гайд для разработчиков

ChatGPT API Python — один из самых востребованных навыков для разработчиков в 2026 году. OpenAI предоставляет мощный API, который позволяет интегрировать возможности GPT-4o, GPT-4.1 и других моделей в любое приложение на Python. В этом гайде мы пройдём весь путь: от установки SDK до продвинутых техник — function calling, structured output и оптимизации стоимости.

Если вас интересует работа с Claude API от Anthropic — у нас есть отдельный гайд по Claude API с примерами кода.

ChatGPT API Python: установка и первый запрос

Получение API-ключа

Для работы с OpenAI API нужен аккаунт и API-ключ:

1. Зарегистрируйтесь на platform.openai.com.
2. Перейдите в раздел API Keys и создайте новый ключ.
3. Пополните баланс (минимум $5 для начала).

Важно для российских пользователей: OpenAI не принимает российские карты. Варианты оплаты: карта иностранного банка (Казахстан, Грузия, Армения), криптовалюта через некоторые посредники, или использование API-прокси сервисов. Подробнее о доступе к ИИ-сервисам из России — в статье ИИ для российских компаний в условиях санкций.

Установка Python SDK

pip install openai

Текущая версия SDK (1.x) полностью переписана по сравнению с 0.x — убедитесь, что используете актуальную документацию.

Первый запрос к ChatGPT API на Python

from openai import OpenAI

client = OpenAI()  # ключ берётся из переменной OPENAI_API_KEY

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Ты полезный ассистент. Отвечай на русском языке."},
        {"role": "user", "content": "Что такое Transformer в машинном обучении?"}
    ]
)

print(response.choices[0].message.content)
print(f"Токенов: {response.usage.total_tokens}")
print(f"Стоимость: ~${response.usage.total_tokens * 0.0000025:.4f}")

Переменную окружения можно установить так:

export OPENAI_API_KEY="sk-proj-..."

Или передать ключ явно:

client = OpenAI(api_key="sk-proj-...")

Модели OpenAI: какую выбрать для ChatGPT API Python

Для большинства задач gpt-4.1-mini — оптимальный выбор по соотношению цена/качество. Сравнение с конкурентами — в статье Claude vs ChatGPT.

Потоковая генерация (streaming) в ChatGPT API Python

Streaming позволяет получать ответ по частям, не дожидаясь полной генерации. Это критично для чат-ботов и интерактивных приложений:

from openai import OpenAI

client = OpenAI()

stream = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[
        {"role": "system", "content": "Ты эксперт по Python."},
        {"role": "user", "content": "Напиши декоратор для кэширования с TTL."}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()  # перенос строки в конце

Async streaming

Для асинхронных приложений (FastAPI, aiohttp) используйте AsyncOpenAI:

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI()

async def generate():
    stream = await client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{"role": "user", "content": "Привет, как дела?"}],
        stream=True
    )
    async for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)

asyncio.run(generate())

Function Calling: подключение внешних инструментов

Function calling — одна из самых мощных возможностей ChatGPT API. Модель сама решает, когда вызвать функцию, и формирует аргументы в JSON. Это позволяет создавать AI-агентов, которые взаимодействуют с внешними системами.

Подробнее о концепции AI-агентов — в нашей статье AI-агенты: что это и как работают.

Пример: бот с доступом к погоде и курсам валют

import json
from openai import OpenAI

client = OpenAI()

# Определяем инструменты
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Получить текущую погоду в городе",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Название города"}
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_exchange_rate",
            "description": "Получить курс валюты к рублю",
            "parameters": {
                "type": "object",
                "properties": {
                    "currency": {"type": "string", "description": "Код валюты (USD, EUR)"}
                },
                "required": ["currency"]
            }
        }
    }
]

# Имитация реальных функций
def get_weather(city: str) -> str:
    # В реальном приложении — запрос к API погоды
    return json.dumps({"city": city, "temp": 12, "condition": "облачно"})

def get_exchange_rate(currency: str) -> str:
    rates = {"USD": 92.5, "EUR": 100.3}
    return json.dumps({"currency": currency, "rate": rates.get(currency, 0)})

# Маппинг имён функций на реализации
available_functions = {
    "get_weather": get_weather,
    "get_exchange_rate": get_exchange_rate
}

# Основной цикл
messages = [
    {"role": "system", "content": "Ты ассистент. Используй инструменты для ответа."},
    {"role": "user", "content": "Какая погода в Москве и какой курс доллара?"}
]

response = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Обработка вызовов функций
message = response.choices[0].message
if message.tool_calls:
    messages.append(message)  # добавляем ответ модели с tool_calls
    
    for tool_call in message.tool_calls:
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)
        result = available_functions[func_name](**func_args)
        
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })
    
    # Второй вызов — модель формулирует финальный ответ
    final = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=messages
    )
    print(final.choices[0].message.content)

Structured Output: гарантированная структура ответа

Structured Output позволяет получить от модели ответ строго в заданной JSON-схеме. Это убирает необходимость парсить свободный текст и обрабатывать ошибки формата.

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI()

class ProductReview(BaseModel):
    sentiment: str  # "positive", "negative", "neutral"
    score: int  # 1-10
    key_points: list[str]
    summary: str

response = client.beta.chat.completions.parse(
    model="gpt-4.1-mini",
    messages=[
        {"role": "system", "content": "Анализируй отзывы на товары."},
        {"role": "user", "content": "Отзыв: Ноутбук отличный, батарея держит 10 часов, но клавиатура могла бы быть лучше. Экран шикарный, звук так себе."}
    ],
    response_format=ProductReview
)

review = response.choices[0].message.parsed
print(f"Тональность: {review.sentiment}")
print(f"Оценка: {review.score}/10")
print(f"Ключевые моменты: {review.key_points}")
print(f"Резюме: {review.summary}")

Structured Output гарантирует, что ответ всегда соответствует схеме — модель не может вернуть невалидный JSON.

ChatGPT API Python: обработка изображений (Vision)

GPT-4o и GPT-4.1 поддерживают анализ изображений через API:

from openai import OpenAI
import base64

client = OpenAI()

# Загрузка изображения из файла
with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Опиши, что изображено на скриншоте. Если это интерфейс — перечисли элементы."},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}",
                        "detail": "high"
                    }
                }
            ]
        }
    ]
)

print(response.choices[0].message.content)

Параметр detail контролирует качество анализа: "low" — быстро и дёшево (85 токенов), "high" — детально (до 1700 токенов за изображение).

Оптимизация стоимости ChatGPT API Python

API OpenAI тарифицируется по токенам. Вот проверенные способы снизить расходы:

1. Выбирайте правильную модель

Не используйте gpt-4.1 для задач, с которыми справится gpt-4.1-nano. Классификация, извлечение данных, простые ответы — всё это работает на mini и nano моделях с экономией в 5–20 раз.

2. Оптимизируйте системный промпт

Системный промпт отправляется с каждым запросом. Если он занимает 2000 токенов и вы делаете 10 000 запросов/день — это 20 млн токенов только на промпт. Сократите его до необходимого минимума.

3. Используйте кэширование

OpenAI автоматически кэширует запросы с одинаковым префиксом (Prompt Caching) — кэшированные токены стоят на 50% дешевле. Структурируйте промпты так, чтобы неизменная часть (инструкции, примеры) шла первой.

# Хорошо: статическая часть первой — кэшируется
messages = [
    {"role": "system", "content": long_instruction},   # кэшируется
    {"role": "user", "content": few_shot_examples},     # кэшируется
    {"role": "user", "content": dynamic_user_input}      # уникальная часть
]

4. Ограничивайте длину ответа

response = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=messages,
    max_tokens=500  # ограничение длины ответа
)

5. Используйте batch API для некритичных задач

OpenAI Batch API позволяет отправлять запросы пакетами с гарантией выполнения за 24 часа — со скидкой 50% от стоимости:

# Создание batch-файла (JSONL)
batch_input = [
    {
        "custom_id": "req-1",
        "method": "POST",
        "url": "/v1/chat/completions",
        "body": {
            "model": "gpt-4.1-mini",
            "messages": [{"role": "user", "content": "Переведи: Привет, мир"}]
        }
    }
    # ... тысячи запросов
]

# Загрузка и запуск batch
batch_file = client.files.create(file=open("batch.jsonl", "rb"), purpose="batch")
batch_job = client.batches.create(input_file_id=batch_file.id, endpoint="/v1/chat/completions", completion_window="24h")

Обработка ошибок и rate limits

Продакшен-код должен корректно обрабатывать ошибки API:

import time
from openai import OpenAI, RateLimitError, APIError, APITimeoutError

client = OpenAI(timeout=30.0, max_retries=3)

def safe_completion(messages, model="gpt-4.1-mini", max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model=model,
                messages=messages
            )
        except RateLimitError:
            wait_time = 2 ** attempt  # exponential backoff
            print(f"Rate limit, жду {wait_time}с...")
            time.sleep(wait_time)
        except APITimeoutError:
            print(f"Таймаут, попытка {attempt + 1}/{max_retries}")
            continue
        except APIError as e:
            print(f"Ошибка API: {e}")
            raise
    raise Exception("Превышено количество попыток")

SDK OpenAI (v1.x) имеет встроенные retry с экспоненциальным backoff — параметр max_retries при создании клиента. Но для продакшена рекомендуется дополнительная обработка на уровне приложения.

Полный пример: чат-бот на FastAPI

Соберём всё вместе — простой чат-бот с историей сообщений, streaming и обработкой ошибок:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from openai import AsyncOpenAI

app = FastAPI()
client = AsyncOpenAI()

class ChatRequest(BaseModel):
    messages: list[dict]
    model: str = "gpt-4.1-mini"

@app.post("/chat")
async def chat(request: ChatRequest):
    system_msg = {
        "role": "system",
        "content": "Ты полезный ассистент. Отвечай на русском языке. Будь конкретным."
    }
    messages = [system_msg] + request.messages
    
    async def generate():
        stream = await client.chat.completions.create(
            model=request.model,
            messages=messages,
            stream=True
        )
        async for chunk in stream:
            if chunk.choices[0].delta.content:
                yield chunk.choices[0].delta.content
    
    return StreamingResponse(generate(), media_type="text/plain")

Запуск: uvicorn main:app --reload

ChatGPT API Python: лучшие практики

• Всегда устанавливайте таймаут. По умолчанию SDK ждёт 10 минут — для продакшена это слишком много. Ставьте 30–60 секунд.
• Логируйте usage. Записывайте response.usage для каждого запроса — это позволит контролировать расходы и оптимизировать промпты.
• Используйте переменные окружения для API-ключей. Никогда не хардкодьте ключи в коде.
• Тестируйте на дешёвых моделях. Разрабатывайте и отлаживайте на gpt-4.1-nano, переключайтесь на gpt-4.1 для продакшена.
• Следите за обновлениями. OpenAI регулярно выпускает новые модели и API-фичи. Подписывайтесь на наш разбор релизов и дайджест ИИ-новостей.

Заключение

ChatGPT API Python — мощный и хорошо документированный инструмент, который открывает разработчикам доступ к лучшим языковым моделям. Ключевые возможности — streaming, function calling и structured output — покрывают подавляющее большинство задач: от простых чат-ботов до сложных AI-агентов.

Для старта достаточно 10 строк кода и $5 на балансе. Для продакшена — добавьте обработку ошибок, кэширование, мониторинг расходов и выберите оптимальную модель для каждой задачи. А если вам нужна альтернатива OpenAI — изучите Claude API от Anthropic и DeepSeek как бюджетный вариант с открытыми весами. Общий обзор LLM и их возможностей — в нашем полном гайде по LLM для разработчиков.