ChatGPT API Python Tutorial: Step-by-Step 2026 Beginner Guide

This tutorial walks you through using the ChatGPT API in Python from scratch. By the end you will know how to send prompts, stream responses, handle conversation history, control the model’s behavior with temperature and system prompts, and estimate costs. The whole thing takes about 25 minutes and under 60 lines of code.

What the ChatGPT API actually is

The ChatGPT API is OpenAI’s hosted service for sending prompts to GPT models from your code. You send a request with a list of messages and a model name; OpenAI runs the inference on their servers and returns the response. Behind “ChatGPT API” in casual usage are two separate APIs: the Chat Completions API (the stable, mature endpoint used in production everywhere) and the Responses API (introduced in 2025 for more complex workflows). This tutorial focuses on Chat Completions because it is simpler and still the right default in 2026.

What you need before starting

• Python 3.10 or newer
• An OpenAI account with API access (free to sign up at platform.openai.com)
• A funded API account (minimum $5 to activate the API; expect to spend well under $1 for this tutorial)
• Your API key, which starts with sk-

Step 1: Install and configure

pip install openai python-dotenv

Create a .env file in your project folder:

OPENAI_API_KEY=sk-your-key-here

Never hardcode your API key in source files. Loading from .env or environment variables is the standard pattern.

Step 2: Your first API call

Create hello.py:

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Explain what the ChatGPT API is in one paragraph."}],
)
print(response.choices[0].message.content)

Run python hello.py. You should see a paragraph explaining the ChatGPT API. If this works, your key and install are fine.

Note: starting with gpt-4o-mini (the cheapest frontier model from OpenAI in 2026) keeps your learning cost under a few cents.

Step 3: Understand the message format

Every ChatGPT API request takes a list of messages. Each message has a role (system, user, or assistant) and content:

• system: sets the model’s persona, constraints, and instructions. Comes first in the list.
• user: what the human says. Carries the actual question or request.
• assistant: previous responses from the model. Used to build multi-turn conversations.

messages = [
    {"role": "system", "content": "You are a helpful cooking assistant. Keep answers under 80 words."},
    {"role": "user", "content": "How long should I bake chicken thighs?"},
    {"role": "assistant", "content": "Bake bone-in thighs at 425F for 35 to 40 minutes until the internal temperature hits 175F."},
    {"role": "user", "content": "What about boneless?"},
]

In this example, the system message establishes the persona, the first user message asks a question, the assistant’s prior answer is included, and the follow-up user message asks a related question. Because the full history is in the list, the model knows “What about boneless?” refers to chicken thighs.

Step 4: Control the model with parameters

The three parameters you will tune most often:

• model: pick gpt-4o-mini for cost, gpt-4o for the standard quality/price sweet spot, or gpt-5 for the hardest reasoning tasks
• temperature: 0 to 2. Lower is more deterministic (0 for coding, extraction, classification). Higher is more creative (0.7 to 1.0 for creative writing).
• max_tokens or max_completion_tokens: caps the output length. Useful for keeping costs predictable.

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Write a two-sentence product tagline for a notebook app."}],
    temperature=0.8,
    max_tokens=100,
)

Step 5: Stream the response

For a chat-style user interface, streaming makes the response feel faster:

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Tell me about the planet Mars."}],
    stream=True,
)
for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()

Each chunk carries a small piece of the response. Print as it arrives. The total time is the same but perceived latency drops noticeably.

Step 6: Build a conversation loop

Pull it all together in a command-line chatbot:

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

history = [
    {"role": "system", "content": "You are a helpful assistant. Keep answers brief."},
]

print("Chat with GPT. Type 'quit' to exit.")
while True:
    user = input("\nYou: ").strip()
    if user.lower() in ("quit", "exit", ""):
        break
    history.append({"role": "user", "content": user})

    stream = client.chat.completions.create(
        model="gpt-4o",
        messages=history,
        stream=True,
    )

    print("\nGPT: ", end="", flush=True)
    full = ""
    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            print(content, end="", flush=True)
            full += content
    print()
    history.append({"role": "assistant", "content": full})

Costs in 2026

Pricing per million tokens (September 2026):

• GPT-4o-mini: $0.15 input / $0.60 output
• GPT-4o: $2.50 input / $10 output
• GPT-5: $15 input / $75 output

A typical chat exchange (300 tokens in, 400 tokens out) costs roughly $0.004 on GPT-4o. For most learning projects you will spend under $1 total.

Frequently Asked Questions

Mary Grace G. Patulada

Programmer & Technical Writer at PIES IT Solution

Mary Grace G. Patulada (pen name ‘Nym’) is a programmer and writer at PIES IT Solution with a BSIT background from Carlos Hilado Memorial State College, Binalbagan Campus. Authored 370+ UML diagram tutorials and capstone documentation guides at itsourcecode.com. Specializes in UML (class, use case, activity, sequence, component, deployment), DFD, and ER diagrams for BSIT capstone projects.

Expertise: UML Diagrams, DFD, ER Diagrams, Use Case Diagrams, Activity Diagrams, Capstone Documentation, PHP · View all posts by Mary Grace G. Patulada →